From 86f7f7fc546016647e3283db35584e0a13624063 Mon Sep 17 00:00:00 2001 From: Brian O'Kelley Date: Wed, 15 Apr 2026 08:14:13 +0100 Subject: [PATCH 1/2] =?UTF-8?q?feat:=20close=20schema=20pipeline=20gap=20?= =?UTF-8?q?=E2=80=94=20full=20type=20coverage=20+=20tool=20schema=20maps?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Extend generate-types.ts to compile all ~170 missing JSON schemas (enums, pricing options, asset types, brand protocol, governance helpers, collection types, signal definitions, etc.) - core.generated.ts: 195 → 376 exports, schemas.generated.ts: 508 Zod schemas - Add TOOL_REQUEST_SCHEMAS (Zod map keyed by tool name) for MCP server.tool() - Export TOOL_RESPONSE_SCHEMAS from index.ts (was internal-only) - Replace 3 hand-written brand response schemas with generated ones - Add collection list tools to response schema map - Add -I timestamp flag to ci:schema-check for local parity with CI Co-Authored-By: Claude Opus 4.6 (1M context) --- .changeset/warm-impalas-press.md | 5 + package.json | 2 +- scripts/generate-types.ts | 141 +- src/lib/index.ts | 5 + src/lib/types/core.generated.ts | 5979 ++++++++++++++++++++++++- src/lib/types/schemas.generated.ts | 5911 ++++++++++++++---------- src/lib/utils/response-schemas.ts | 28 +- src/lib/utils/tool-request-schemas.ts | 95 + 8 files changed, 9687 insertions(+), 2479 deletions(-) create mode 100644 .changeset/warm-impalas-press.md create mode 100644 src/lib/utils/tool-request-schemas.ts diff --git a/.changeset/warm-impalas-press.md b/.changeset/warm-impalas-press.md new file mode 100644 index 00000000..e35710ea --- /dev/null +++ b/.changeset/warm-impalas-press.md @@ -0,0 +1,5 @@ +--- +'@adcp/client': minor +--- + +Close schema pipeline gap: generate TypeScript types and Zod schemas for all missing JSON schemas, add TOOL_REQUEST_SCHEMAS and TOOL_RESPONSE_SCHEMAS exports diff --git a/package.json b/package.json index e8470598..69afcb28 100644 --- a/package.json +++ b/package.json @@ -107,7 +107,7 @@ "docs:open": "open docs/api/index.html || xdg-open docs/api/index.html || start docs/api/index.html", "ci:validate": "node scripts/ci-validate.js", "ci:quick": "npm run format:check && npm run typecheck && npm run build:lib && npm test", - "ci:schema-check": "npm run sync-schemas && npm run generate-types && npm run generate-registry-types && git diff --exit-code src/lib/types/ src/lib/agents/ src/lib/registry/types.generated.ts schemas/registry/registry.yaml || (echo '⚠️ Generated files are out of sync. Run: npm run sync-schemas && npm run generate-types && npm run generate-registry-types' && exit 1)", + "ci:schema-check": "npm run sync-schemas && npm run generate-types && npm run generate-registry-types && git diff --exit-code -I '// Generated at:' src/lib/types/ src/lib/agents/ src/lib/registry/types.generated.ts schemas/registry/registry.yaml || (echo '⚠️ Generated files are out of sync. Run: npm run sync-schemas && npm run generate-types && npm run generate-registry-types' && exit 1)", "ci:docs-check": "npm run generate-agent-docs && git diff --exit-code -I '> Generated at:' docs/llms.txt docs/TYPE-SUMMARY.md || (echo '⚠️ Agent docs are out of sync. Run: npm run generate-agent-docs' && exit 1)", "ci:pre-push": "npm run ci:schema-check && npm run ci:quick", "hooks:install": "node scripts/install-hooks.js", diff --git a/scripts/generate-types.ts b/scripts/generate-types.ts index daa8291b..64dad577 100644 --- a/scripts/generate-types.ts +++ b/scripts/generate-types.ts @@ -1,6 +1,6 @@ #!/usr/bin/env tsx -import { writeFileSync, mkdirSync, readFileSync, existsSync } from 'fs'; +import { writeFileSync, mkdirSync, readFileSync, existsSync, readdirSync, statSync } from 'fs'; import { compile } from 'json-schema-to-typescript'; import path from 'path'; import { removeArrayLengthConstraints } from './schema-utils'; @@ -1168,6 +1168,136 @@ export class AgentCollection { return agentClass; } +/** + * Recursively discover all JSON schema files in the cache directory. + * Returns relative paths from LATEST_CACHE_DIR (e.g., "core/format.json", "enums/channels.json"). + */ +function discoverAllSchemaFiles(dir: string, base: string = dir): string[] { + const results: string[] = []; + for (const entry of readdirSync(dir)) { + const fullPath = path.join(dir, entry); + if (statSync(fullPath).isDirectory()) { + // Skip tmp directory + if (entry === 'tmp') continue; + results.push(...discoverAllSchemaFiles(fullPath, base)); + } else if (entry.endsWith('.json') && entry !== 'index.json') { + results.push(path.relative(base, fullPath)); + } + } + return results; +} + +/** + * Convert a schema file path to a PascalCase type name. + * e.g., "core/format.json" -> "Format" + * "enums/pricing-model.json" -> "PricingModel" + * "core/assets/html-asset.json" -> "HtmlAsset" + * "pricing-options/cpm-option.json" -> "CpmOption" + * "brand/rights-pricing-option.json" -> "RightsPricingOption" + */ +function schemaPathToTypeName(relativePath: string): string { + const fileName = path.basename(relativePath, '.json'); + return fileName + .split('-') + .map(part => part.charAt(0).toUpperCase() + part.slice(1)) + .join(''); +} + +/** + * Compile all schemas that weren't already generated by the root schema or tool passes. + * This fills the gap for standalone schemas in core/, enums/, pricing-options/, brand/, etc. + * + * Skips: + * - Task request/response schemas (already generated as tool types) + * - Root aggregation schemas (brand.json, adagents.json at top level) + * - Schemas whose type names were already generated via $ref resolution + * - Async response variant schemas (working/submitted/input-required) + */ +async function compileGapSchemas( + generatedTypes: Set, + refResolver: any, +): Promise { + const allFiles = discoverAllSchemaFiles(LATEST_CACHE_DIR); + const gapCode: string[] = []; + + // Directories that contain task request/response schemas (already covered by tool generation) + const taskDirs = new Set(['account', 'media-buy', 'creative', 'signals', 'governance', + 'protocol', 'sponsored-intelligence', 'compliance', 'content-standards', 'property', 'collection']); + + // Patterns that indicate task request/response schemas + const taskSchemaPattern = /-(request|response)\.json$/; + // Async response variants are always generated alongside their parent tool + const asyncVariantPattern = /-async-response-(working|submitted|input-required)\.json$/; + + // Top-level aggregation schemas (not standalone types) + const skipFiles = new Set(['adagents.json', 'brand.json']); + + let compiledCount = 0; + + for (const relPath of allFiles.sort()) { + // Skip top-level aggregation files + if (!relPath.includes('/') && skipFiles.has(relPath)) continue; + + const dir = relPath.split('/')[0]; + + // Skip task request/response schemas in task directories + if (taskDirs.has(dir) && taskSchemaPattern.test(relPath)) continue; + + // Skip async response variants + if (asyncVariantPattern.test(relPath)) continue; + + const typeName = schemaPathToTypeName(relPath); + + // Skip if this type was already generated + if (generatedTypes.has(typeName)) continue; + + // Skip deprecated schemas + if (DEPRECATED_SCHEMAS.has(path.basename(relPath, '.json'))) continue; + + try { + const schemaPath = path.join(LATEST_CACHE_DIR, relPath); + let schema = JSON.parse(readFileSync(schemaPath, 'utf8')); + + // Apply same preprocessing as other schema passes + const fileName = path.basename(relPath, '.json'); + if (DEPRECATED_ENUM_VALUES[fileName]) { + schema = removeDeprecatedFields(schema, fileName); + } + const pascalName = schemaPathToTypeName(relPath); + if (DEPRECATED_SCHEMA_FIELDS[pascalName]) { + schema = removeDeprecatedFields(schema, pascalName); + } + if (BACKWARD_COMPAT_OPTIONAL_FIELDS[pascalName]) { + schema = makeFieldsOptional(schema, BACKWARD_COMPAT_OPTIONAL_FIELDS[pascalName]); + } + + const strictSchema = enforceStrictSchema(removeArrayLengthConstraints(schema)); + const types = await compile(strictSchema, typeName, { + bannerComment: '', + style: { semi: true, singleQuote: true }, + additionalProperties: false, + strictIndexSignatures: true, + $refOptions: { + resolve: { + cache: refResolver, + }, + }, + }); + + const filtered = filterDuplicateTypeDefinitions(types, generatedTypes); + if (filtered.trim()) { + gapCode.push(`// ${relPath}\n${filtered}`); + compiledCount++; + } + } catch (error: any) { + console.warn(`⚠️ Failed to compile gap schema ${relPath}: ${error.message}`); + } + } + + console.log(`📦 Compiled ${compiledCount} gap schemas`); + return gapCode.join('\n\n'); +} + async function generateTypes() { console.log('🔄 Generating AdCP types and fluent API...'); @@ -1310,6 +1440,15 @@ async function generateTypes() { toolTypes = removeNumberedTypeDuplicates(toolTypes); toolTypes = fixTypedIndexSignatures(toolTypes); + // Compile gap schemas: all schemas not already generated by root schema passes. + // Only dedup against core types (not tool types) because gap schemas go into + // core.generated.ts which is a separate file from tools.generated.ts. + console.log('\n🔍 Scanning for gap schemas...'); + const gapTypes = await compileGapSchemas(new Set(generatedCoreTypes), refResolver); + if (gapTypes.trim()) { + coreTypes += `\n// GAP SCHEMAS — types not reachable from root schemas or tool definitions\n${gapTypes}\n`; + } + // Generate Agent classes const agentClasses = generateAgentClasses(tools); diff --git a/src/lib/index.ts b/src/lib/index.ts index 621a056e..1b70564d 100644 --- a/src/lib/index.ts +++ b/src/lib/index.ts @@ -527,6 +527,11 @@ export const PreviewCreativeVariantRequestSchema = _variant; // Auth utilities for custom integrations export { getAuthToken, createAdCPHeaders, createMCPAuthHeaders, createAuthenticatedFetch } from './auth'; +// ====== TOOL SCHEMA MAPS ====== +// Zod schemas keyed by tool name — use with server.tool(name, schema.shape, handler) +export { TOOL_REQUEST_SCHEMAS } from './utils/tool-request-schemas'; +export { TOOL_RESPONSE_SCHEMAS } from './utils/response-schemas'; + // ====== VALIDATION ====== // Schema validation for requests/responses export { validateAgentUrl, validateAdCPResponse, getExpectedSchema, handleAdCPResponse } from './validation'; diff --git a/src/lib/types/core.generated.ts b/src/lib/types/core.generated.ts index b11c589a..86c8eb23 100644 --- a/src/lib/types/core.generated.ts +++ b/src/lib/types/core.generated.ts @@ -1,5 +1,5 @@ // Generated AdCP core types from official schemas vlatest -// Generated at: 2026-04-15T04:10:44.458Z +// Generated at: 2026-04-15T05:55:01.955Z // MEDIA-BUY SCHEMA /** @@ -5337,3 +5337,5980 @@ export interface SyncCatalogsAsyncSubmitted { ext?: ExtensionObject; } + +// GAP SCHEMAS — types not reachable from root schemas or tool definitions +// a2ui/component.json +/** + * A component in an A2UI surface + */ +export interface A2UIComponent { + /** + * Unique identifier for this component within the surface + */ + id: string; + /** + * ID of the parent component (null for root) + */ + parentId?: string; + /** + * Component definition (keyed by component type) + */ + component: { + /** + * Component properties + */ + [k: string]: {} | undefined; + }; +} + + +// a2ui/surface.json +/** + * A contiguous UI region containing components + */ +export interface A2UISurface { + /** + * Unique identifier for this surface + */ + surfaceId: string; + /** + * Component catalog to use for rendering + */ + catalogId?: string; + /** + * Flat list of components (adjacency list structure) + */ + components: A2UIComponent[]; + /** + * ID of the root component (if not specified, first component is root) + */ + rootId?: string; + /** + * Application data that components can bind to + */ + dataModel?: {}; +} + +// brand/acquire-rights-request.json +/** + * Authentication schemes for push notification endpoints + */ +export type AuthenticationScheme = 'Bearer' | 'HMAC-SHA256'; + +/** + * Binding contractual request to acquire rights from a brand agent. Parallels create_media_buy — the buyer selects a pricing_option_id from a get_rights response and provides campaign details. The agent clears against existing contracts and returns terms, generation credentials, and disclosure requirements. + */ +export interface AcquireRightsRequest { + /** + * The AdCP major version the buyer's payloads conform to. Sellers validate against their supported major_versions and return VERSION_UNSUPPORTED if unsupported. When omitted, the seller assumes its highest supported version. + */ + adcp_major_version?: number; + /** + * Rights offering identifier from get_rights response + */ + rights_id: string; + /** + * Selected pricing option from the rights offering + */ + pricing_option_id: string; + buyer: BrandReference; + /** + * Campaign details for rights clearance + */ + campaign: { + /** + * Description of how the rights will be used + */ + description: string; + /** + * Specific rights uses for this campaign + */ + uses: RightUse[]; + /** + * Countries where the campaign will run (ISO 3166-1 alpha-2) + */ + countries?: string[]; + /** + * Creative formats that will be produced + */ + format_ids?: FormatID[]; + /** + * Estimated total impressions for the campaign + */ + estimated_impressions?: number; + /** + * Campaign start date (ISO 8601) + */ + start_date?: string; + /** + * Campaign end date (ISO 8601) + */ + end_date?: string; + }; + revocation_webhook: PushNotificationConfig; + push_notification_config?: PushNotificationConfig; + /** + * Client-generated key for safe retries. Resubmitting with the same key returns the original response rather than creating a duplicate acquisition. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request. + */ + idempotency_key?: string; + context?: ContextObject; + ext?: ExtensionObject; +} +/** + * Webhook for rights revocation notifications. If the rights holder needs to revoke rights (talent scandal, contract violation, etc.), they POST a revocation-notification to this URL. The buyer is responsible for stopping creative delivery upon receipt. + */ +export interface PushNotificationConfig { + /** + * Webhook endpoint URL for task status notifications + */ + url: string; + /** + * Optional client-provided token for webhook validation. Echoed back in webhook payload to validate request authenticity. + */ + token?: string; + /** + * Authentication configuration for webhook delivery (A2A-compatible) + */ + authentication: { + /** + * Array of authentication schemes. Supported: ['Bearer'] for simple token auth, ['HMAC-SHA256'] for signature verification (recommended for production) + */ + schemes: AuthenticationScheme[]; + /** + * Credentials for authentication. For Bearer: token sent in Authorization header. For HMAC-SHA256: shared secret used to generate signature. Minimum 32 characters. Exchanged out-of-band during onboarding. + */ + credentials: string; + }; +} +/** + * Result of a rights acquisition request. Returns one of three statuses: acquired (with terms and generation credentials), pending_approval (requires rights holder review), or rejected (with reason). Uses discriminated union on status field. + */ +export type AcquireRightsResponse = + | AcquireRightsAcquired + | AcquireRightsPendingApproval + | AcquireRightsRejected + | AcquireRightsError; +export interface AcquireRightsAcquired { + /** + * Rights grant identifier + */ + rights_id: string; + /** + * Rights have been cleared and credentials issued + */ + status: 'acquired'; + /** + * Brand identifier of the rights subject + */ + brand_id: string; + terms: RightsTerms; + /** + * Scoped credentials for generating rights-cleared content + */ + generation_credentials: GenerationCredential[]; + /** + * Usage restrictions and requirements + */ + restrictions?: string[]; + /** + * Required disclosure for creatives using these rights + */ + disclosure?: { + /** + * Whether disclosure is required + */ + required: boolean; + /** + * Disclosure text to include with the creative + */ + text?: string; + }; + approval_webhook?: PushNotificationConfig; + /** + * Endpoint for reporting usage against these rights + */ + usage_reporting_url?: string; + rights_constraint: RightsConstraint; + context?: ContextObject; + ext?: ExtensionObject; +} +/** + * Agreed contractual terms + */ +export interface RightsTerms { + pricing_option_id: string; + amount: number; + currency: string; + period?: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'annual' | 'one_time'; + uses: RightUse[]; + impression_cap?: number; + overage_cpm?: number; + start_date?: string; + end_date?: string; + /** + * Exclusivity terms if applicable + */ + exclusivity?: { + scope?: string; + countries?: string[]; + }; +} +/** + * A scoped credential issued by an LLM provider for generating rights-cleared content. The rights agent coordinates with the provider to issue the credential; the provider enforces usage constraints at generation time. Any creative agent can use the credential. + */ +export interface GenerationCredential { + /** + * LLM or generation service provider identifier (e.g., 'midjourney', 'elevenlabs', 'stability') + */ + provider: string; + /** + * Scoped API key or token for generating rights-cleared content. The provider validates this key at generation time to verify the caller is authorized. + */ + rights_key: string; + /** + * Which rights uses this credential covers + */ + uses: RightUse[]; + /** + * When this credential expires. Key lifetime is determined by the provider. + */ + expires_at?: string; + /** + * Provider API endpoint to use with this credential, if different from the provider's default + */ + endpoint?: string; + ext?: ExtensionObject; +} +export interface AcquireRightsPendingApproval { + rights_id: string; + /** + * Rights require approval from the rights holder + */ + status: 'pending_approval'; + brand_id: string; + /** + * Explanation of what requires approval + */ + detail?: string; + /** + * Expected time for approval decision (e.g., '48h', '3 business days') + */ + estimated_response_time?: string; + context?: ContextObject; + ext?: ExtensionObject; +} +export interface AcquireRightsRejected { + rights_id: string; + /** + * Rights request was rejected + */ + status: 'rejected'; + brand_id: string; + /** + * Why the rights request was rejected. May be sanitized to protect confidential brand rules — e.g., 'This violates our public figures brand guidelines' rather than naming the specific rule. + */ + reason: string; + /** + * Actionable alternatives the buyer can try. If present, the rejection is fixable — the buyer can adjust their request. If absent, the rejection is final for this talent/rights combination. + */ + suggestions?: string[]; + context?: ContextObject; + ext?: ExtensionObject; +} +export interface AcquireRightsError { + errors: Error[]; + context?: ContextObject; + ext?: ExtensionObject; +} + +// brand/get-brand-identity-request.json +/** + * Request brand identity data from a brand agent. Core identity (house, names, description, logos) is always public. Linked accounts get deeper data: high-res assets, voice configs, tone guidelines, and rights availability. + */ +export interface GetBrandIdentityRequest { + /** + * The AdCP major version the buyer's payloads conform to. Sellers validate against their supported major_versions and return VERSION_UNSUPPORTED if unsupported. When omitted, the seller assumes its highest supported version. + */ + adcp_major_version?: number; + /** + * Brand identifier from brand.json brands array + */ + brand_id: string; + /** + * Optional identity sections to include in the response. When omitted, all sections the caller is authorized to see are returned. Core fields (brand_id, house, names) are always returned and do not need to be requested. + */ + fields?: ( + | 'description' + | 'industries' + | 'keller_type' + | 'logos' + | 'colors' + | 'fonts' + | 'visual_guidelines' + | 'tone' + | 'tagline' + | 'voice_synthesis' + | 'assets' + | 'rights' + )[]; + /** + * Intended use case, so the agent can tailor the response. A 'voice_synthesis' use case returns voice configs; a 'likeness' use case returns high-res photos and appearance guidelines. + */ + use_case?: string; + context?: ContextObject; + ext?: ExtensionObject; +} + +// brand/get-brand-identity-response.json +/** + * Brand identity data from a brand agent. Core identity (house, names, description, logos) is always public. Authorized callers receive richer data (high-res assets, voice synthesis, tone guidelines, rights availability). Includes available_fields to signal what the caller could unlock by linking their account. + */ +export type GetBrandIdentityResponse = GetBrandIdentitySuccess | GetBrandIdentityError; +/** + * Type of asset content + */ +export type AssetContentType = + | 'image' + | 'video' + | 'audio' + | 'text' + | 'markdown' + | 'html' + | 'css' + | 'javascript' + | 'vast' + | 'daast' + | 'url' + | 'webhook' + | 'brief' + | 'catalog'; +export interface GetBrandIdentitySuccess { + /** + * Brand identifier + */ + brand_id: string; + /** + * The house (corporate entity) this brand belongs to. Always returned regardless of authorization level. + */ + house: { + /** + * House domain (e.g., nikeinc.com) + */ + domain: string; + /** + * House display name + */ + name: string; + }; + /** + * Localized brand names with BCP 47 locale code keys (e.g., 'en_US', 'fr_CA'). Bare language codes ('en') are accepted as wildcards for backwards compatibility. + */ + names: { + [k: string]: string | undefined; + }[]; + /** + * Brand description + */ + description?: string; + /** + * Brand industries. + */ + industries?: string[]; + /** + * Brand architecture type: master (primary brand of house), sub_brand (carries parent name), endorsed (independent identity backed by parent), independent (operates separately) + */ + keller_type?: 'master' | 'sub_brand' | 'endorsed' | 'independent'; + /** + * Brand logos. Public callers get standard logos; authorized callers also receive high-res variants. Shape matches brand.json logo definition. + */ + logos?: { + /** + * URL to the logo asset + */ + url: string; + /** + * Logo aspect ratio orientation + */ + orientation?: 'square' | 'horizontal' | 'vertical' | 'stacked'; + /** + * Background compatibility + */ + background?: 'dark-bg' | 'light-bg' | 'transparent-bg'; + /** + * Logo variant type + */ + variant?: 'primary' | 'secondary' | 'icon' | 'wordmark' | 'full-lockup'; + /** + * Additional semantic tags + */ + tags?: string[]; + /** + * When to use this logo variant + */ + usage?: string; + /** + * Width in pixels + */ + width?: number; + /** + * Height in pixels + */ + height?: number; + }[]; + /** + * Brand color palette. Each role accepts a single hex color or an array of hex colors. Shape matches brand.json colors definition. + */ + colors?: { + primary?: string | string[]; + secondary?: string | string[]; + accent?: string | string[]; + background?: string | string[]; + text?: string | string[]; + }; + /** + * Brand typography. Each key is a role name (e.g., 'primary', 'secondary') referenced by type_scale entries. Values are either a CSS font-family string or a structured object with family name and font files. Shape matches brand.json fonts definition. + */ + fonts?: { + /** + * Primary font family + */ + primary?: + | string + | { + /** + * CSS font-family name + */ + family: string; + files?: { + /** + * HTTPS URL to the font file + */ + url: string; + /** + * CSS numeric font-weight + */ + weight?: number; + /** + * Variable font weight axis range as [min, max] + */ + weight_range?: number[]; + /** + * CSS font-style + */ + style?: 'normal' | 'italic' | 'oblique'; + }[]; + /** + * OpenType feature tags to enable (e.g., ['ss01', 'tnum']) + */ + opentype_features?: string[]; + /** + * Ordered fallback font-family names for script coverage + */ + fallbacks?: string[]; + }; + /** + * Secondary font family + */ + secondary?: + | string + | { + /** + * CSS font-family name + */ + family: string; + files?: { + /** + * HTTPS URL to the font file + */ + url: string; + /** + * CSS numeric font-weight + */ + weight?: number; + /** + * Variable font weight axis range as [min, max] + */ + weight_range?: number[]; + /** + * CSS font-style + */ + style?: 'normal' | 'italic' | 'oblique'; + }[]; + /** + * OpenType feature tags to enable (e.g., ['ss01', 'tnum']) + */ + opentype_features?: string[]; + /** + * Ordered fallback font-family names for script coverage + */ + fallbacks?: string[]; + }; + [k: string]: + | ( + | string + | { + /** + * CSS font-family name + */ + family: string; + files?: { + /** + * HTTPS URL to the font file + */ + url: string; + /** + * CSS numeric font-weight + */ + weight?: number; + /** + * Variable font weight axis range as [min, max] + */ + weight_range?: number[]; + /** + * CSS font-style + */ + style?: 'normal' | 'italic' | 'oblique'; + }[]; + /** + * OpenType feature tags to enable (e.g., ['ss01', 'tnum']) + */ + opentype_features?: string[]; + /** + * Ordered fallback font-family names for script coverage + */ + fallbacks?: string[]; + } + ) + | undefined; + }; + /** + * Structured visual rules for generative creative systems (photography, graphic_style, colorways, type_scale, motion). Matches brand.json visual_guidelines definition. Authorized callers only. + */ + visual_guidelines?: {}; + /** + * Brand voice and messaging guidelines + */ + tone?: { + /** + * Brand personality described as comma-separated adjectives (e.g., 'enthusiastic, warm, competitive') + */ + voice?: string; + /** + * Personality traits that characterize the brand voice, used as prompt guidance + */ + attributes?: string[]; + /** + * Approved messaging approaches, content themes, and reference points + */ + dos?: string[]; + /** + * Prohibited topics, competitor references, and phrasings to avoid + */ + donts?: string[]; + }; + /** + * Brand tagline or slogan. Accepts a plain string or a localized array matching the names pattern. + */ + tagline?: + | string + | { + [k: string]: string | undefined; + }[]; + /** + * Voice synthesis configuration for AI-generated audio + */ + voice_synthesis?: { + provider?: string; + voice_id?: string; + settings?: {}; + }; + /** + * Available brand assets (images, audio, video). Authorized callers only. Shape matches brand.json asset definition. + */ + assets?: { + /** + * Unique identifier + */ + asset_id: string; + asset_type: AssetContentType; + /** + * URL to CDN-hosted asset file + */ + url: string; + /** + * Tags for discovery + */ + tags?: string[]; + /** + * Human-readable name + */ + name?: string; + /** + * Asset description or usage notes + */ + description?: string; + /** + * Image/video width in pixels + */ + width?: number; + /** + * Image/video height in pixels + */ + height?: number; + /** + * Video/audio duration in seconds + */ + duration_seconds?: number; + /** + * File size in bytes + */ + file_size_bytes?: number; + /** + * File format (e.g., 'jpg', 'mp4') + */ + format?: string; + }[]; + /** + * Rights availability summary. For detailed pricing, use get_rights. + */ + rights?: { + available_uses?: RightUse[]; + /** + * Countries where rights are available (ISO 3166-1 alpha-2). If omitted, rights are available worldwide. + */ + countries?: string[]; + /** + * Countries excluded from availability (ISO 3166-1 alpha-2) + */ + excluded_countries?: string[]; + exclusivity_model?: string; + content_restrictions?: string[]; + }; + /** + * Fields available but not returned in this response due to authorization level. Tells the caller what they would gain by linking their account via sync_accounts. Values match the request fields enum. + */ + available_fields?: ( + | 'description' + | 'industries' + | 'keller_type' + | 'logos' + | 'colors' + | 'fonts' + | 'visual_guidelines' + | 'tone' + | 'tagline' + | 'voice_synthesis' + | 'assets' + | 'rights' + )[]; + context?: ContextObject; + ext?: ExtensionObject; +} +export interface GetBrandIdentityError { + errors: Error[]; + context?: ContextObject; + ext?: ExtensionObject; +} + +// brand/get-rights-request.json +/** + * Search for licensable rights across a brand agent's roster. Returns matches with pricing. Discovery is natural-language-first — no taxonomy for categories. The agent interprets intent from the query and filters based on the buyer's brand compatibility. + */ +export interface GetRightsRequest { + /** + * The AdCP major version the buyer's payloads conform to. Sellers validate against their supported major_versions and return VERSION_UNSUPPORTED if unsupported. When omitted, the seller assumes its highest supported version. + */ + adcp_major_version?: number; + /** + * Natural language description of desired rights. The agent interprets intent, budget signals, and compatibility from this text. + */ + query: string; + /** + * Rights uses being requested. The agent returns options covering these uses, potentially bundled into composite pricing. + */ + uses: RightUse[]; + buyer_brand?: BrandReference; + /** + * Countries where rights are needed (ISO 3166-1 alpha-2). Filters to rights available in these markets. + */ + countries?: string[]; + /** + * Search within a specific brand's rights. If omitted, searches across the agent's full roster. + */ + brand_id?: string; + right_type?: RightType; + /** + * Include filtered-out results in the excluded array with reasons. Defaults to false. + */ + include_excluded?: boolean; + pagination?: PaginationRequest; + context?: ContextObject; + ext?: ExtensionObject; +} +/** + * Pagination parameters for large result sets + */ +export interface PaginationRequest { + /** + * Maximum number of items to return per page + */ + max_results?: number; + /** + * Opaque cursor from a previous response to fetch the next page + */ + cursor?: string; +} + +// brand/get-rights-response.json +/** + * Licensable rights matching the search criteria, with pricing options. Each result is a complete snapshot of current availability (stateless, DDEX PIE pattern). Excluded results explain why they were filtered out. + */ +export type GetRightsResponse = GetRightsSuccess | GetRightsError; +/** + * Pricing model (cpm, flat_rate, etc.) + */ +export type PricingModel = 'cpm' | 'vcpm' | 'cpc' | 'cpcv' | 'cpv' | 'cpp' | 'cpa' | 'flat_rate' | 'time'; + +export interface GetRightsSuccess { + /** + * Matching rights with pricing options, ranked by relevance + */ + rights: { + /** + * Identifier for this rights offering. Referenced in acquire_rights. + */ + rights_id: string; + /** + * Brand identifier from the agent's roster + */ + brand_id: string; + /** + * Display name of the rights subject + */ + name: string; + /** + * Description of the rights subject + */ + description?: string; + right_type?: RightType; + /** + * Relevance score from 0 to 1 + */ + match_score?: number; + /** + * Human-readable reasons for the match + */ + match_reasons?: string[]; + /** + * Rights uses available for licensing + */ + available_uses: RightUse[]; + /** + * Countries where rights are available (ISO 3166-1 alpha-2). When both countries and excluded_countries are present, the effective set is countries minus excluded_countries. If neither is present, all countries are available. + */ + countries?: string[]; + /** + * Countries excluded from availability + */ + excluded_countries?: string[]; + /** + * Current exclusivity availability + */ + exclusivity_status?: { + /** + * Whether exclusivity is available + */ + available?: boolean; + /** + * Active exclusivity commitments that may affect availability. Implementers should use vague descriptions ('exclusive commitment in this category') rather than specific deal terms to protect confidential business relationships. + */ + existing_exclusives?: string[]; + }; + /** + * Available pricing options for these rights + */ + pricing_options: RightsPricingOption[]; + /** + * Content restrictions or approval requirements + */ + content_restrictions?: string[]; + /** + * Preview-only assets for evaluation + */ + preview_assets?: { + url: string; + usage?: string; + }[]; + }[]; + /** + * Results that matched but were filtered out, with reasons + */ + excluded?: { + brand_id: string; + name?: string; + /** + * Why this result was excluded. May be sanitized to protect confidential brand rules. + */ + reason: string; + /** + * Actionable alternatives if the exclusion is fixable (e.g., 'Available in BE and DE markets'). Absent if the exclusion is final. + */ + suggestions?: string[]; + }[]; + context?: ContextObject; + ext?: ExtensionObject; +} +/** + * A pricing option for licensable rights. Separate from media-buy pricing options — rights pricing includes period, impression caps, overage rates, and use-type scoping. + */ +export interface RightsPricingOption { + /** + * Unique identifier for this pricing option. Referenced in acquire_rights and report_usage. + */ + pricing_option_id: string; + model: PricingModel; + /** + * Price amount. Interpretation depends on model: CPM = cost per 1,000 impressions, flat_rate = fixed cost per period. + */ + price: number; + /** + * ISO 4217 currency code + */ + currency: string; + /** + * Which rights uses this pricing option covers. A single option can bundle multiple uses (e.g., likeness + voice). + */ + uses: RightUse[]; + /** + * Billing period for flat_rate and time-based models + */ + period?: 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'annual' | 'one_time'; + /** + * Maximum impressions included in this pricing option per period + */ + impression_cap?: number; + /** + * CPM rate applied to impressions exceeding the impression_cap + */ + overage_cpm?: number; + /** + * Human-readable description of this pricing option + */ + description?: string; + ext?: ExtensionObject; +} +export interface GetRightsError { + errors: Error[]; + context?: ContextObject; + ext?: ExtensionObject; +} + +// collection/base-collection-source.json +/** + * A source of collections for a collection list. Supports three selection patterns: distribution identifiers (cross-publisher), publisher-specific collection IDs, or publisher-specific genres. + */ +export type BaseCollectionSource = DistributionIDsSource | PublisherCollectionsSource | PublisherGenresSource; +/** + * Type of distribution identifier + */ +export type DistributionIdentifierType = + | 'apple_podcast_id' + | 'spotify_collection_id' + | 'rss_url' + | 'podcast_guid' + | 'amazon_music_id' + | 'iheart_id' + | 'podcast_index_id' + | 'youtube_channel_id' + | 'youtube_playlist_id' + | 'amazon_title_id' + | 'roku_channel_id' + | 'pluto_channel_id' + | 'tubi_id' + | 'peacock_id' + | 'tiktok_id' + | 'twitch_channel' + | 'imdb_id' + | 'gracenote_id' + | 'eidr_id' + | 'domain' + | 'substack_id'; +/** + * Taxonomy for the genre values. Required so sellers can interpret genre strings unambiguously. Use 'custom' for free-form values negotiated out of band. + */ +export type GenreTaxonomy = + | 'iab_content_3.0' + | 'iab_content_2.2' + | 'gracenote' + | 'eidr' + | 'apple_genres' + | 'google_genres' + | 'roku' + | 'amazon_genres' + | 'custom'; + +/** + * Select collections by platform-independent distribution identifiers. The primary mechanism for cross-publisher collection matching. + */ +export interface DistributionIDsSource { + /** + * Discriminator indicating selection by platform-independent distribution identifiers + */ + selection_type: 'distribution_ids'; + /** + * Platform-independent identifiers (imdb_id, gracenote_id, eidr_id, etc.). Each identifier uniquely identifies a collection across all publishers. + */ + identifiers: { + type: DistributionIdentifierType; + /** + * The identifier value + */ + value: string; + }[]; +} +/** + * Select specific collections within a publisher's adagents.json by collection ID + */ +export interface PublisherCollectionsSource { + /** + * Discriminator indicating selection by specific collection IDs within a publisher + */ + selection_type: 'publisher_collections'; + /** + * Domain where publisher's adagents.json is hosted + */ + publisher_domain: string; + /** + * Specific collection IDs from the publisher's adagents.json + */ + collection_ids: string[]; +} +/** + * Select all collections from a publisher matching genre criteria. Use when excluding entire content categories from a specific publisher. + */ +export interface PublisherGenresSource { + /** + * Discriminator indicating selection by genre within a publisher + */ + selection_type: 'publisher_genres'; + /** + * Domain where publisher's adagents.json is hosted + */ + publisher_domain: string; + /** + * Genre values to match against the publisher's collections + */ + genres: string[]; + genre_taxonomy: GenreTaxonomy; +} + + +// collection/collection-list-changed-webhook.json +/** + * Webhook notification sent when a collection list's resolved collections change. Contains a summary only — recipients must call get_collection_list to retrieve the updated collections. + */ +export interface CollectionListChangedWebhook { + /** + * The event type + */ + event: 'collection_list_changed'; + /** + * ID of the collection list that changed + */ + list_id: string; + /** + * Name of the collection list + */ + list_name?: string; + /** + * Summary of changes to the resolved list + */ + change_summary?: { + /** + * Number of collections added since last resolution + */ + collections_added?: number; + /** + * Number of collections removed since last resolution + */ + collections_removed?: number; + /** + * Total collections in the resolved list + */ + total_collections?: number; + }; + /** + * When the list was re-resolved + */ + resolved_at: string; + /** + * When the consumer should refresh from the governance agent + */ + cache_valid_until?: string; + /** + * Cryptographic signature of the webhook payload, signed with the agent's private key. Recipients MUST verify this signature. + */ + signature: string; + ext?: ExtensionObject; +} + +// collection/collection-list-filters.json +/** + * Production quality tier for collection content. Maps to OpenRTB content.prodq: professional=1, prosumer=2, ugc=3. Seller-declared — no external validation. + */ +export type ProductionQuality = 'professional' | 'prosumer' | 'ugc'; + +/** + * Filters that dynamically modify a collection list when resolved. Include filters are allowlists (only matching collections pass). Exclude filters are blocklists (matching collections are removed). When both are present for the same dimension, include is applied first, then exclude narrows further. + */ +export interface CollectionListFilters { + /** + * Exclude collections with any of these content ratings (OR logic). This is a metadata filter on the collection's declared content_rating field — it does not evaluate episode content. + */ + content_ratings_exclude?: ContentRating[]; + /** + * Include only collections with any of these content ratings (OR logic). Collections without a declared content_rating are excluded. + */ + content_ratings_include?: ContentRating[]; + /** + * Exclude collections tagged with any of these genres (OR logic). Values are interpreted against genre_taxonomy when present. + */ + genres_exclude?: string[]; + /** + * Include only collections with any of these genres (OR logic). Collections without genre metadata are excluded. Values are interpreted against genre_taxonomy when present. + */ + genres_include?: string[]; + genre_taxonomy?: GenreTaxonomy; + /** + * Filter to these collection kinds + */ + kinds?: ('series' | 'publication' | 'event_series' | 'rotation')[]; + /** + * Always exclude collections with these distribution identifiers + */ + exclude_distribution_ids?: { + type: DistributionIdentifierType; + /** + * The identifier value + */ + value: string; + }[]; + /** + * Filter by production quality tier + */ + production_quality?: ProductionQuality[]; +} + +// collection/collection-list.json +/** + * A managed collection list with optional filters for dynamic evaluation. Lists are resolved at setup time and cached by orchestrators/sellers for real-time use. Collections represent programs, shows, and other content entities independent of which properties carry them. + */ +export interface CollectionList { + /** + * Unique identifier for this collection list + */ + list_id: string; + /** + * Human-readable name for the list + */ + name: string; + /** + * Description of the list's purpose + */ + description?: string; + /** + * Principal identity that owns this list + */ + principal?: string; + /** + * Array of collection sources to evaluate. Each entry is a discriminated union: distribution_ids (platform-independent identifiers), publisher_collections (publisher_domain + collection_ids), or publisher_genres (publisher_domain + genres). If omitted, queries the agent's entire collection database. + */ + base_collections?: BaseCollectionSource[]; + filters?: CollectionListFilters; + brand?: BrandReference; + /** + * URL to receive notifications when the resolved list changes + */ + webhook_url?: string; + /** + * Recommended cache duration for resolved list. Consumers should re-fetch after this period. Defaults to 168 (one week) because collection metadata changes less frequently than property metadata. + */ + cache_duration_hours?: number; + /** + * When the list was created + */ + created_at?: string; + /** + * When the list was last modified + */ + updated_at?: string; + /** + * Number of collections in the resolved list (at time of last resolution) + */ + collection_count?: number; +} + +// content-standards/artifact-webhook-payload.json +/** + * Authentication for secured URLs + */ +export type AssetAccess = + | { + method: 'bearer_token'; + /** + * OAuth2 bearer token for Authorization header + */ + token: string; + } + | { + method: 'service_account'; + /** + * Cloud provider + */ + provider: 'gcp' | 'aws'; + /** + * Service account credentials + */ + credentials?: {}; + } + | { + method: 'signed_url'; + }; +/** + * Payload sent by sales agents to orchestrators when pushing content artifacts for governance validation. Complements get_media_buy_artifacts for push-based artifact delivery. + */ +export interface ArtifactWebhookPayload { + /** + * Media buy identifier these artifacts belong to + */ + media_buy_id: string; + /** + * Unique identifier for this batch of artifacts. Use for deduplication and acknowledgment. + */ + batch_id: string; + /** + * When this batch was generated (ISO 8601) + */ + timestamp: string; + /** + * Content artifacts from delivered impressions + */ + artifacts: { + artifact: Artifact; + /** + * When the impression was delivered (ISO 8601) + */ + delivered_at: string; + /** + * Optional impression identifier for correlation with delivery reports + */ + impression_id?: string; + /** + * Package within the media buy this artifact relates to + */ + package_id?: string; + }[]; + /** + * Pagination info when batching large artifact sets + */ + pagination?: { + /** + * Total artifacts in the delivery period + */ + total_artifacts?: number; + /** + * Current batch number (1-indexed) + */ + batch_number?: number; + /** + * Total batches for this delivery period + */ + total_batches?: number; + }; + ext?: ExtensionObject; +} +/** + * The content artifact + */ +export interface Artifact { + /** + * Stable property identifier from the property catalog. Globally unique across the ecosystem. + */ + property_rid: string; + /** + * Identifier for this artifact within the property. The property owner defines the scheme (e.g., 'article_12345', 'episode_42_segment_3', 'post_abc123'). + */ + artifact_id: string; + /** + * Identifies a specific variant of this artifact. Use for A/B tests, translations, or temporal versions. Examples: 'en', 'es-MX', 'v2', 'headline_test_b'. The combination of artifact_id + variant_id must be unique. + */ + variant_id?: string; + format_id?: FormatID; + /** + * Optional URL for this artifact (web page, podcast feed, video page). Not all artifacts have URLs (e.g., Instagram content, podcast segments, TV scenes). + */ + url?: string; + /** + * When the artifact was published (ISO 8601 format) + */ + published_time?: string; + /** + * When the artifact was last modified (ISO 8601 format) + */ + last_update_time?: string; + /** + * Artifact assets in document flow order - text blocks, images, video, audio + */ + assets: ( + | { + type: 'text'; + /** + * Role of this text in the document. Use 'title' for the main artifact title, 'description' for summaries. + */ + role?: 'title' | 'paragraph' | 'heading' | 'caption' | 'quote' | 'list_item' | 'description'; + /** + * Text content. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation. + */ + content: string; + /** + * MIME type indicating how to parse the content field. Default: text/plain. + */ + content_format?: 'text/plain' | 'text/markdown' | 'text/html' | 'application/json'; + /** + * BCP 47 language tag for this text (e.g., 'en', 'es-MX'). Useful when artifact contains mixed-language content. + */ + language?: string; + /** + * Heading level (1-6), only for role=heading + */ + heading_level?: number; + provenance?: Provenance; + } + | { + type: 'image'; + /** + * Image URL + */ + url: string; + access?: AssetAccess; + /** + * Alt text or image description + */ + alt_text?: string; + /** + * Image caption + */ + caption?: string; + /** + * Image width in pixels + */ + width?: number; + /** + * Image height in pixels + */ + height?: number; + provenance?: Provenance; + } + | { + type: 'video'; + /** + * Video URL + */ + url: string; + access?: AssetAccess; + /** + * Video duration in milliseconds + */ + duration_ms?: number; + /** + * Video transcript. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation. + */ + transcript?: string; + /** + * MIME type indicating how to parse the transcript field. Default: text/plain. + */ + transcript_format?: 'text/plain' | 'text/markdown' | 'application/json'; + /** + * How the transcript was generated + */ + transcript_source?: 'original_script' | 'subtitles' | 'closed_captions' | 'dub' | 'generated'; + /** + * Video thumbnail URL + */ + thumbnail_url?: string; + provenance?: Provenance; + } + | { + type: 'audio'; + /** + * Audio URL + */ + url: string; + access?: AssetAccess; + /** + * Audio duration in milliseconds + */ + duration_ms?: number; + /** + * Audio transcript. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation. + */ + transcript?: string; + /** + * MIME type indicating how to parse the transcript field. Default: text/plain. + */ + transcript_format?: 'text/plain' | 'text/markdown' | 'application/json'; + /** + * How the transcript was generated + */ + transcript_source?: 'original_script' | 'closed_captions' | 'generated'; + provenance?: Provenance; + } + )[]; + /** + * Rich metadata extracted from the artifact + */ + metadata?: { + /** + * Canonical URL + */ + canonical?: string; + /** + * Artifact author name + */ + author?: string; + /** + * Artifact keywords + */ + keywords?: string; + /** + * Open Graph protocol metadata + */ + open_graph?: {}; + /** + * Twitter Card metadata + */ + twitter_card?: {}; + /** + * JSON-LD structured data (schema.org) + */ + json_ld?: {}[]; + }; + provenance?: Provenance; + /** + * Platform-specific identifiers for this artifact + */ + identifiers?: { + /** + * Apple Podcasts ID + */ + apple_podcast_id?: string; + /** + * Spotify collection ID + */ + spotify_collection_id?: string; + /** + * Podcast GUID (from RSS feed) + */ + podcast_guid?: string; + /** + * YouTube video ID + */ + youtube_video_id?: string; + /** + * RSS feed URL + */ + rss_url?: string; + }; +} + +// content-standards/content-standards.json +/** + * A pricing option offered by a vendor agent (signals, creative, governance). Combines pricing_option_id with the pricing model fields. Pass pricing_option_id in report_usage for billing verification. All vendor discovery responses return pricing_options as an array — vendors may offer multiple options (volume tiers, context-specific rates, different models per product line). + */ +export type VendorPricingOption = { + /** + * Opaque identifier for this pricing option, unique within the vendor agent. Pass this in report_usage to identify which pricing option was applied. + */ + pricing_option_id: string; +} & VendorPricing; +/** + * Pricing model for a vendor service. Discriminated by model: 'cpm' (fixed CPM), 'percent_of_media' (percentage of spend with optional CPM cap), 'flat_fee' (fixed charge per reporting period), or 'per_unit' (fixed price per unit of work). + */ +export type VendorPricing = CpmPricing | PercentOfMediaPricing | FlatFeePricing | PerUnitPricing; + +/** + * A content standards configuration defining brand safety and suitability policies. Standards are scoped by brand, geography, and channel. Multiple standards can be active simultaneously for different scopes. + */ +export interface ContentStandards { + /** + * Unique identifier for this standards configuration + */ + standards_id: string; + /** + * Human-readable name for this standards configuration + */ + name?: string; + /** + * ISO 3166-1 alpha-2 country codes. Standards apply in ALL listed countries (AND logic). + */ + countries_all?: string[]; + /** + * Advertising channels. Standards apply to ANY of the listed channels (OR logic). + */ + channels_any?: MediaChannel[]; + /** + * BCP 47 language tags (e.g., 'en', 'de', 'fr'). Standards apply to content in ANY of these languages (OR logic). Content in unlisted languages is not covered by these standards. + */ + languages_any?: string[]; + /** + * Natural language policy describing acceptable and unacceptable content contexts. Used by LLMs and human reviewers to make judgments. + */ + policy?: string; + /** + * Training/test set to calibrate policy interpretation. Provides concrete examples of pass/fail decisions. + */ + calibration_exemplars?: { + /** + * Artifacts that pass the content standards + */ + pass?: Artifact[]; + /** + * Artifacts that fail the content standards + */ + fail?: Artifact[]; + }; + /** + * Pricing options for this content standards service. The buyer passes the selected pricing_option_id in report_usage for billing verification. + */ + pricing_options?: VendorPricingOption[]; + ext?: ExtensionObject; +} +/** + * Fixed cost per thousand impressions + */ +export interface CpmPricing { + model: 'cpm'; + /** + * Cost per thousand impressions + */ + cpm: number; + /** + * ISO 4217 currency code + */ + currency: string; + ext?: ExtensionObject; +} +/** + * Percentage of media spend charged for this signal. When max_cpm is set, the effective rate is capped at that CPM — useful for platforms like The Trade Desk that use percent-of-media pricing with a CPM ceiling. + */ +export interface PercentOfMediaPricing { + model: 'percent_of_media'; + /** + * Percentage of media spend, e.g. 15 = 15% + */ + percent: number; + /** + * Optional CPM cap. When set, the effective charge is min(percent × media_spend_per_mille, max_cpm). + */ + max_cpm?: number; + /** + * ISO 4217 currency code for the resulting charge + */ + currency: string; + ext?: ExtensionObject; +} +/** + * Fixed charge per billing period, regardless of impressions or spend. Used for licensed data bundles and audience subscriptions. + */ +export interface FlatFeePricing { + model: 'flat_fee'; + /** + * Fixed charge for the billing period + */ + amount: number; + /** + * Billing period for the flat fee. + */ + period: 'monthly' | 'quarterly' | 'annual' | 'campaign'; + /** + * ISO 4217 currency code + */ + currency: string; + ext?: ExtensionObject; +} +/** + * Fixed price per unit of work. Used for creative transformation (per format), AI generation (per image, per token), and rendering (per variant). The unit field describes what is counted; unit_price is the cost per one unit. + */ +export interface PerUnitPricing { + model: 'per_unit'; + /** + * What is counted — e.g. 'format', 'image', 'token', 'variant', 'render', 'evaluation'. + */ + unit: string; + /** + * Cost per one unit + */ + unit_price: number; + /** + * ISO 4217 currency code + */ + currency: string; + ext?: ExtensionObject; +} + + +// core/account-ref.json +/** + * Reference to an account by seller-assigned ID or natural key. Use account_id for explicit accounts (require_operator_auth: true, discovered via list_accounts). Use the natural key (brand + operator) for implicit accounts (require_operator_auth: false, declared via sync_accounts). For sandbox: explicit accounts use account_id (pre-existing test account), implicit accounts use the natural key with sandbox: true. + */ +export type AccountReference = + | { + /** + * Seller-assigned account identifier (from sync_accounts or list_accounts) + */ + account_id: string; + } + | { + brand: BrandReference; + /** + * Domain of the entity operating on the brand's behalf. When the brand operates directly, this is the brand's domain. + */ + operator: string; + /** + * When true, references the sandbox account for this brand/operator pair. Defaults to false (production account). + */ + sandbox?: boolean; + }; + +// core/activation-key.json +/** + * Universal identifier for using a signal on a destination platform. Can be either a segment ID or a key-value pair depending on the platform's targeting mechanism. + */ +export type ActivationKey = + | { + /** + * Segment ID based targeting + */ + type: 'segment_id'; + /** + * The platform-specific segment identifier to use in campaign targeting + */ + segment_id: string; + } + | { + /** + * Key-value pair based targeting + */ + type: 'key_value'; + /** + * The targeting parameter key + */ + key: string; + /** + * The targeting parameter value + */ + value: string; + }; + + +// core/agent-signing-key.json +/** + * Publisher-attested public key material for an authorized agent. Buyers use these keys to verify signed agent responses against the trust anchor published in adagents.json rather than trusting key discovery from the agent domain alone. + */ +export interface AgentSigningKey { + /** + * Key identifier for selecting the correct signing key. + */ + kid: string; + /** + * JWK key type, such as 'OKP', 'EC', or 'RSA'. + */ + kty: string; + /** + * Expected signing algorithm for this key, such as 'EdDSA' or 'RS256'. + */ + alg?: string; + /** + * Optional JWK use value. Typically 'sig' for signing keys. + */ + use?: string; + /** + * Curve name for OKP or EC keys, such as 'Ed25519' or 'P-256'. + */ + crv?: string; + /** + * Base64url-encoded public key x coordinate or public key value for OKP keys. + */ + x?: string; + /** + * Base64url-encoded public key y coordinate for EC keys. + */ + y?: string; + /** + * Base64url-encoded RSA modulus. + */ + n?: string; + /** + * Base64url-encoded RSA public exponent. + */ + e?: string; +} + + +// core/attribution-window.json +/** + * Attribution model used to assign credit when multiple touchpoints exist + */ +export type AttributionModel = 'last_touch' | 'first_touch' | 'linear' | 'time_decay' | 'data_driven'; + +/** + * Describes the attribution methodology and lookback windows used for conversion measurement. Enables cross-platform comparison by making attribution methodology transparent. + */ +export interface AttributionWindow { + /** + * Post-click attribution window. Conversions occurring within this duration after a click are attributed to the ad. + */ + post_click?: Duration; + /** + * Post-view attribution window. Conversions occurring within this duration after an ad impression (without click) are attributed to the ad. + */ + post_view?: Duration; + model: AttributionModel; +} + +// core/audience-member.json +/** + * A CRM audience member identified by a buyer-assigned external_id and at least one matchable identifier. All identifiers must be normalized before hashing: emails to lowercase+trim, phone numbers to E.164 format (e.g. +12065551234). Providing multiple identifiers for the same person improves match rates. Composite identifiers (e.g. hashed first name + last name + zip for Google Customer Match) are not yet standardized — use the ext field for platform-specific extensions. + */ +export type AudienceMember = { + [k: string]: unknown | undefined; +} & { + /** + * Buyer-assigned stable identifier for this audience member (e.g. CRM record ID, loyalty ID). Used for deduplication, removal, and cross-referencing with buyer systems. Adapters for CDPs that don't natively assign IDs can derive one (e.g. hash of the member's identifiers). + */ + external_id: string; + /** + * SHA-256 hash of lowercase, trimmed email address. + */ + hashed_email?: string; + /** + * SHA-256 hash of E.164-formatted phone number (e.g. +12065551234). + */ + hashed_phone?: string; + /** + * Universal ID values (MAIDs, RampID, UID2, etc.) for user matching. + */ + uids?: { + type: UIDType; + /** + * Universal ID value + */ + value: string; + }[]; + ext?: ExtensionObject; +}; +/** + * Universal ID type + */ +export type UIDType = + | 'rampid' + | 'id5' + | 'uid2' + | 'euid' + | 'pairid' + | 'maid' + | 'hashed_email' + | 'publisher_first_party' + | 'other'; + + +// core/catchment.json +/** + * A catchment area definition for a store or location. Defines the geographic area from which a store draws customers. Three methods are supported: isochrone inputs (travel time + transport mode, platform resolves the shape), simple radius (distance from location), or pre-computed GeoJSON geometry (buyer provides the exact boundary). Provide exactly one method per catchment. + */ +export type Catchment = { + /** + * Identifier for this catchment, used to reference specific catchment areas in targeting (e.g., 'walk', 'drive', 'primary'). + */ + catchment_id: string; + /** + * Human-readable label for this catchment (e.g., '15-min drive', '1km walking radius'). + */ + label?: string; + /** + * Travel time limit for isochrone calculation. The platform resolves this to a geographic boundary based on actual transportation networks, accounting for road connectivity, transit schedules, and terrain. + */ + travel_time?: { + /** + * Travel time limit. + */ + value: number; + /** + * Time unit. + */ + unit: 'min' | 'hr'; + }; + transport_mode?: TransportMode; + /** + * Simple radius from the store location. The platform draws a circle of this distance around the store's coordinates. + */ + radius?: { + /** + * Radius distance. + */ + value: number; + unit: DistanceUnit; + }; + /** + * Pre-computed GeoJSON geometry defining the catchment boundary. Use this when the buyer has already calculated isochrones (via TravelTime, Mapbox, etc.) or has custom trade area boundaries. Supports Polygon and MultiPolygon types. + */ + geometry?: { + /** + * GeoJSON geometry type. + */ + type: 'Polygon' | 'MultiPolygon'; + /** + * GeoJSON coordinates array. For Polygon: array of linear rings. For MultiPolygon: array of polygons. + */ + coordinates: unknown[]; + }; + ext?: ExtensionObject; +} & { + [k: string]: unknown | undefined; +}; +/** + * Transportation mode for isochrone calculation. Required when travel_time is provided. + */ +export type TransportMode = 'walking' | 'cycling' | 'driving' | 'public_transport'; +/** + * Distance unit. + */ +export type DistanceUnit = 'km' | 'mi' | 'm'; + + +// core/collection-distribution.json +/** + * A collection's presence on a specific publisher platform, identified by platform-specific identifiers. Enables cross-seller matching when the same collection is sold by different agents. + */ +export interface CollectionDistribution { + /** + * Domain of the publisher platform where the collection is distributed (e.g., 'youtube.com', 'spotify.com') + */ + publisher_domain: string; + /** + * Platform-specific identifiers for the collection on this publisher + */ + identifiers: { + type: DistributionIdentifierType; + /** + * The identifier value + */ + value: string; + }[]; +} + + +// core/collection.json +/** + * How frequently the collection releases new installments + */ +export type CollectionCadence = 'daily' | 'weekly' | 'monthly' | 'seasonal' | 'event' | 'irregular'; +/** + * Lifecycle status of the collection + */ +export type CollectionStatus = 'active' | 'hiatus' | 'ended' | 'upcoming'; +/** + * How the collections are related + */ +export type CollectionRelationship = 'spinoff' | 'companion' | 'sequel' | 'prequel' | 'crossover'; + +/** + * A recurring inventory container — a named program, publication, event series, or rotation that produces bookable installments on a defined cadence. The kind field indicates how to interpret this collection: 'series' for TV/podcast programs, 'publication' for print/newsletter titles, 'event_series' for live events, 'rotation' for DOOH scheduling. Declared in the publisher's adagents.json and referenced by products via collection selectors. + */ +export interface Collection { + /** + * Publisher-assigned identifier for this collection. Declared in the publisher's adagents.json collections array. Products reference collections via collection selectors with publisher_domain and collection_ids. Use distribution identifiers for cross-seller matching across publishers. + */ + collection_id: string; + /** + * Human-readable collection name + */ + name: string; + /** + * What kind of content program this is. Helps agents interpret installments correctly: 'series' installments are TV/podcast episodes, 'publication' installments are print issues, 'event_series' installments are live event airings, 'rotation' installments are DOOH scheduling periods. Defaults to 'series' when absent. + */ + kind?: 'series' | 'publication' | 'event_series' | 'rotation'; + /** + * What the collection is about + */ + description?: string; + /** + * Genre tags. When genre_taxonomy is present, values are taxonomy IDs (e.g., IAB Content Taxonomy 3.0 codes). Otherwise free-form. + */ + genre?: string[]; + /** + * Taxonomy system for genre values (e.g., 'iab_content_3.0'). When present, genre values should be valid taxonomy IDs. Recommended for machine-readable brand safety evaluation. + */ + genre_taxonomy?: string; + /** + * Primary language (BCP 47 tag, e.g., 'en', 'es-MX') + */ + language?: string; + content_rating?: ContentRating; + cadence?: CollectionCadence; + /** + * Current or most recent season identifier (e.g., '3', '2026', 'spring_2026'). A lightweight label — not a full season object. + */ + season?: string; + status?: CollectionStatus; + production_quality?: ProductionQuality; + /** + * Hosts, recurring cast, creators associated with the collection. Each talent entry may include a brand_url linking to their brand.json identity. + */ + talent?: Talent[]; + special?: Special; + limited_series?: LimitedSeries; + /** + * Where this collection is distributed. Each entry maps the collection to a publisher platform with platform-specific identifiers. Collections SHOULD include at least one platform-independent identifier (imdb_id, gracenote_id, eidr_id) when available. + */ + distribution?: CollectionDistribution[]; + deadline_policy?: DeadlinePolicy; + /** + * Relationships to other collections (spin-offs, companion collections, etc.). Each entry references another collection by collection_id within the same publisher's adagents.json. + */ + related_collections?: { + /** + * The related collection's collection_id within this seller's response + */ + collection_id: string; + relationship: CollectionRelationship; + }[]; + ext?: ExtensionObject; +} +/** + * When present, this collection is a limited series — a bounded run with a defined arc, installment count, and end date. + */ +export interface LimitedSeries { + /** + * Planned number of installments in the series + */ + total_installments: number; + /** + * When the series begins (ISO 8601) + */ + starts?: string; + /** + * When the series ends (ISO 8601) + */ + ends?: string; +} +/** + * Default deadline rules for installments of this collection. Agents compute absolute deadlines from each installment's scheduled_at and these lead times. Installments with explicit deadlines override this policy. + */ +export interface DeadlinePolicy { + /** + * Days before scheduled_at by which the placement must be booked + */ + booking_lead_days?: number; + /** + * Days before scheduled_at by which cancellation is penalty-free + */ + cancellation_lead_days?: number; + /** + * Default material submission stages. Items MUST be in chronological order (earliest due first). Agents compute due_at as: installment.scheduled_at minus lead_days. + */ + material_stages?: { + /** + * Stage identifier. Standard values: 'draft' (needs seller processing), 'final' (production-ready). + */ + stage: string; + /** + * Days before scheduled_at this stage is due + */ + lead_days: number; + /** + * What the seller needs at this stage + */ + label?: string; + }[]; + /** + * When true, lead_days counts business days (Mon-Fri) rather than calendar days. Defaults to false. + */ + business_days_only?: boolean; +} + +// core/creative-filters.json +/** + * Filter criteria for querying creatives from a creative library. By default, archived creatives are excluded from results. To include archived creatives, explicitly filter by status='archived' or include 'archived' in the statuses array. + */ +export interface CreativeFilters { + /** + * Filter creatives by owning accounts. Useful for agencies managing multiple client accounts. + */ + accounts?: AccountReference[]; + /** + * Filter by creative approval statuses + */ + statuses?: CreativeStatus[]; + /** + * Filter by creative tags (all tags must match) + */ + tags?: string[]; + /** + * Filter by creative tags (any tag must match) + */ + tags_any?: string[]; + /** + * Filter by creative names containing this text (case-insensitive) + */ + name_contains?: string; + /** + * Filter by specific creative IDs + */ + creative_ids?: string[]; + /** + * Filter creatives created after this date (ISO 8601) + */ + created_after?: string; + /** + * Filter creatives created before this date (ISO 8601) + */ + created_before?: string; + /** + * Filter creatives last updated after this date (ISO 8601) + */ + updated_after?: string; + /** + * Filter creatives last updated before this date (ISO 8601) + */ + updated_before?: string; + /** + * Filter creatives assigned to any of these packages. Sales-agent-specific — standalone creative agents SHOULD ignore this filter. + */ + assigned_to_packages?: string[]; + /** + * Filter creatives assigned to any of these media buys. Sales-agent-specific — standalone creative agents SHOULD ignore this filter. + */ + media_buy_ids?: string[]; + /** + * Filter for unassigned creatives when true, assigned creatives when false. Sales-agent-specific — standalone creative agents SHOULD ignore this filter. + */ + unassigned?: boolean; + /** + * When true, return only creatives that have served at least one impression. When false, return only creatives that have never served. + */ + has_served?: boolean; + /** + * Filter by creative concept IDs. Concepts group related creatives across sizes and formats (e.g., Flashtalking concepts, Celtra campaign folders, CM360 creative groups). + */ + concept_ids?: string[]; + /** + * Filter by structured format IDs. Returns creatives that match any of these formats. + */ + format_ids?: FormatID[]; + /** + * When true, return only creatives with dynamic variables (DCO). When false, return only static creatives. + */ + has_variables?: boolean; +} + +// core/creative-item.json +/** + * Item within a multi-asset creative format. Used for carousel products, native ad components, and other formats composed of multiple distinct elements. + */ +export type CreativeItem = + | { + /** + * Discriminator indicating this is a media asset with content_uri + */ + asset_kind: 'media'; + /** + * Type of asset. Common types: thumbnail_image, product_image, featured_image, logo + */ + asset_type: string; + /** + * Unique identifier for the asset within the creative + */ + asset_id: string; + /** + * URL for media assets (images, videos, etc.) + */ + content_uri: string; + } + | { + /** + * Discriminator indicating this is a text asset with content + */ + asset_kind: 'text'; + /** + * Type of asset. Common types: headline, body_text, cta_text, price_text, sponsor_name, author_name, click_url + */ + asset_type: string; + /** + * Unique identifier for the asset within the creative + */ + asset_id: string; + /** + * Text content for text-based assets like headlines, body text, CTA text, etc. + */ + content: string | string[]; + }; + + +// core/creative-variable.json +/** + * A dynamic content variable (DCO slot) on a creative. Variables represent content that can change at serve time — headlines, images, product data, etc. + */ +export interface CreativeVariable { + /** + * Variable identifier on the creative platform + */ + variable_id: string; + /** + * Human-readable variable name + */ + name: string; + /** + * Data type of the variable. Each type represents a semantic content slot: text (headlines, body copy), image/video/audio (media URLs), url (clickthrough or tracking URLs), number (prices, counts), boolean (conditional flags like show_discount or is_raining), color (hex color values), date (ISO 8601 date-time for countdowns and offer expirations). + */ + variable_type: 'text' | 'image' | 'video' | 'audio' | 'url' | 'number' | 'boolean' | 'color' | 'date'; + /** + * Default value used when no dynamic value is provided at serve time. All types are string-encoded: text/image/video/audio/url as literal strings, number as decimal (e.g., "42.99"), boolean as "true"/"false", color as "#RRGGBB", date as ISO 8601 (e.g., "2026-12-25T00:00:00Z"). + */ + default_value?: string; + /** + * Whether this variable must have a value for the creative to serve + */ + required?: boolean; +} + + +// core/creative-variant.json +/** + * A specific execution variant of a creative with delivery metrics. For catalog-driven packages, each catalog item rendered as a distinct ad execution is a variant — the variant's manifest includes the catalog reference with the specific item rendered. For asset group optimization, represents one combination of assets the platform selected. For generative creative, represents a platform-generated variant. For standard creatives, maps 1:1 with the creative itself. + */ +export type CreativeVariant = DeliveryMetrics & { + /** + * Platform-assigned identifier for this variant + */ + variant_id: string; + manifest?: CreativeManifest; + /** + * Input signals that triggered generation of this variant (Tier 3). Describes why the platform created this specific variant. Platforms should provide summarized or anonymized signals rather than raw user input. For web contexts, may include page topic or URL. For conversational contexts, an anonymized content signal. For search, query category or intent. When the content context is managed through AdCP content standards, reference the artifact directly via the artifact field. + */ + generation_context?: { + /** + * Type of context that triggered generation (e.g., 'web_page', 'conversational', 'search', 'app', 'dooh') + */ + context_type?: string; + /** + * Reference to the content-standards artifact that provided the generation context. Links this variant to the specific piece of content (article, video, podcast segment, etc.) where the ad was placed. + */ + artifact?: { + property_id: Identifier; + /** + * Artifact identifier within the property + */ + artifact_id: string; + }; + ext?: ExtensionObject; + }; +}; +/** + * Standard delivery metrics that can be reported at media buy, package, or creative level + */ +export interface DeliveryMetrics { + /** + * Impressions delivered + */ + impressions?: number; + /** + * Amount spent + */ + spend?: number; + /** + * Total clicks + */ + clicks?: number; + /** + * Click-through rate (clicks/impressions) + */ + ctr?: number; + /** + * Content engagements counted toward the billable view threshold. For video this is a platform-defined view event (e.g., 30 seconds or video midpoint); for audio/podcast it is a stream start; for other formats it follows the pricing model's view definition. When the package uses CPV pricing, spend = views × rate. + */ + views?: number; + /** + * Video/audio completions. When the package has a completed_views optimization goal with view_duration_seconds, completions are counted at that threshold rather than 100% completion. + */ + completed_views?: number; + /** + * Completion rate (completed_views/impressions) + */ + completion_rate?: number; + /** + * Total conversions attributed to this delivery. When by_event_type is present, this equals the sum of all by_event_type[].count entries. + */ + conversions?: number; + /** + * Total monetary value of attributed conversions (in the reporting currency) + */ + conversion_value?: number; + /** + * Return on ad spend (conversion_value / spend) + */ + roas?: number; + /** + * Cost per conversion (spend / conversions) + */ + cost_per_acquisition?: number; + /** + * Fraction of conversions from first-time brand buyers (0 = none, 1 = all) + */ + new_to_brand_rate?: number; + /** + * Leads generated (convenience alias for by_event_type where event_type='lead') + */ + leads?: number; + /** + * Conversion metrics broken down by event type. Spend-derived metrics (ROAS, CPA) are only available at the package/totals level since spend cannot be attributed to individual event types. + */ + by_event_type?: { + event_type: EventType; + /** + * Event source that produced these conversions (for disambiguation when multiple event sources are configured) + */ + event_source_id?: string; + /** + * Number of events of this type + */ + count: number; + /** + * Total monetary value of events of this type + */ + value?: number; + }[]; + /** + * Gross Rating Points delivered (for CPP) + */ + grps?: number; + /** + * Unique reach in the units specified by reach_unit. When reach_unit is omitted, units are unspecified — do not compare reach values across packages or media buys without a common reach_unit. + */ + reach?: number; + /** + * Unit of measurement for the reach field. Aligns with the reach_unit declared on optimization goals and delivery forecasts. Required when reach is present to enable cross-platform comparison. + */ + reach_unit?: ReachUnit; + /** + * Average frequency per reach unit (typically measured over campaign duration, but can vary by measurement provider). When reach_unit is 'households', this is average exposures per household; when 'accounts', per logged-in account; etc. + */ + frequency?: number; + /** + * Audio/video quartile completion data + */ + quartile_data?: { + /** + * 25% completion views + */ + q1_views?: number; + /** + * 50% completion views + */ + q2_views?: number; + /** + * 75% completion views + */ + q3_views?: number; + /** + * 100% completion views + */ + q4_views?: number; + }; + /** + * DOOH-specific metrics (only included for DOOH campaigns) + */ + dooh_metrics?: { + /** + * Number of times ad played in rotation + */ + loop_plays?: number; + /** + * Number of unique screens displaying the ad + */ + screens_used?: number; + /** + * Total display time in seconds + */ + screen_time_seconds?: number; + /** + * Actual share of voice delivered (0.0 to 1.0) + */ + sov_achieved?: number; + /** + * Explanation of how DOOH impressions were calculated + */ + calculation_notes?: string; + /** + * Per-venue performance breakdown + */ + venue_breakdown?: { + /** + * Venue identifier + */ + venue_id: string; + /** + * Human-readable venue name + */ + venue_name?: string; + /** + * Venue type (e.g., 'airport', 'transit', 'retail', 'billboard') + */ + venue_type?: string; + /** + * Impressions delivered at this venue + */ + impressions: number; + /** + * Loop plays at this venue + */ + loop_plays?: number; + /** + * Number of screens used at this venue + */ + screens_used?: number; + }[]; + }; + /** + * Viewability metrics. Viewable rate should be calculated as viewable_impressions / measurable_impressions (not total impressions), since some environments cannot measure viewability. + */ + viewability?: { + /** + * Impressions where viewability could be measured. Excludes environments without measurement capability (e.g., non-Intersection Observer browsers, certain app environments). + */ + measurable_impressions?: number; + /** + * Impressions that met the viewability threshold defined by the measurement standard. + */ + viewable_impressions?: number; + /** + * Viewable impression rate (viewable_impressions / measurable_impressions). Range 0.0 to 1.0. + */ + viewable_rate?: number; + standard?: ViewabilityStandard; + }; + /** + * Total engagements — direct interactions with the ad beyond viewing. Includes social reactions/comments/shares, story/unit opens, interactive overlay taps on CTV, companion banner interactions on audio. Platform-specific; corresponds to the 'engagements' optimization metric. + */ + engagements?: number; + /** + * New followers, page likes, artist/podcast/channel subscribes attributed to this delivery. + */ + follows?: number; + /** + * Saves, bookmarks, playlist adds, pins attributed to this delivery. + */ + saves?: number; + /** + * Visits to the brand's in-platform page (profile, artist page, channel, or storefront) attributed to this delivery. Does not include external website clicks. + */ + profile_visits?: number; + /** + * Platform-specific engagement rate (0.0 to 1.0). Typically engagements/impressions, but definition varies by platform. + */ + engagement_rate?: number; + /** + * Cost per click (spend / clicks) + */ + cost_per_click?: number; + /** + * Conversion metrics broken down by action source (website, app, in_store, etc.). Useful for omnichannel sellers where conversions occur across digital and physical channels. + */ + by_action_source?: { + action_source: ActionSource; + /** + * Event source that produced these conversions (for disambiguation when multiple event sources are configured) + */ + event_source_id?: string; + /** + * Number of conversions from this action source + */ + count: number; + /** + * Total monetary value of conversions from this action source + */ + value?: number; + }[]; +} +/** + * Property where the artifact appears + */ +export interface Identifier { + type: PropertyIdentifierTypes; + /** + * The identifier value. For domain type: 'example.com' matches base domain plus www and m subdomains; 'edition.example.com' matches that specific subdomain; '*.example.com' matches ALL subdomains but NOT base domain + */ + value: string; +} + + +// core/date-range.json +/** + * A date range with inclusive start and end dates (ISO 8601 calendar dates). Used for billing periods, flight dates, and other calendar-day boundaries. + */ +export interface DateRange { + /** + * Start date (inclusive), ISO 8601 + */ + start: string; + /** + * End date (inclusive), ISO 8601 + */ + end: string; +} + + +// core/datetime-range.json +/** + * A datetime range with inclusive start and end timestamps (ISO 8601 with timezone). Used for measurement windows, reporting periods, and other sub-day precision boundaries. + */ +export interface DatetimeRange { + /** + * Start timestamp (inclusive), ISO 8601 + */ + start: string; + /** + * End timestamp (inclusive), ISO 8601 + */ + end: string; +} + + +// core/deployment.json +/** + * A signal deployment to a specific deployment target with activation status and key + */ +export type Deployment = + | { + /** + * Discriminator indicating this is a platform-based deployment + */ + type: 'platform'; + /** + * Platform identifier for DSPs + */ + platform: string; + /** + * Account identifier if applicable + */ + account?: string; + /** + * Whether signal is currently active on this deployment + */ + is_live: boolean; + activation_key?: ActivationKey; + /** + * Estimated time to activate if not live, or to complete activation if in progress + */ + estimated_activation_duration_minutes?: number; + /** + * Timestamp when activation completed (if is_live=true) + */ + deployed_at?: string; + } + | { + /** + * Discriminator indicating this is an agent URL-based deployment + */ + type: 'agent'; + /** + * URL identifying the deployment agent + */ + agent_url: string; + /** + * Account identifier if applicable + */ + account?: string; + /** + * Whether signal is currently active on this deployment + */ + is_live: boolean; + activation_key?: ActivationKey; + /** + * Estimated time to activate if not live, or to complete activation if in progress + */ + estimated_activation_duration_minutes?: number; + /** + * Timestamp when activation completed (if is_live=true) + */ + deployed_at?: string; + }; + +// core/destination-item.json +/** + * A travel destination within a destination-type catalog. Carries the location, imagery, and pricing data that platforms use for destination ads and travel remarketing. Maps to Meta destination catalogs, Google travel ads, and similar formats. + */ +export interface DestinationItem { + /** + * Unique identifier for this destination. + */ + destination_id: string; + /** + * Destination name (e.g., 'Barcelona', 'Bali', 'Swiss Alps'). + */ + name: string; + /** + * Destination description highlighting attractions and appeal. + */ + description?: string; + /** + * City name, if applicable. + */ + city?: string; + /** + * State, province, or region name. + */ + region?: string; + /** + * ISO 3166-1 alpha-2 country code. + */ + country?: string; + /** + * Geographic coordinates of the destination. + */ + location?: { + /** + * Latitude in decimal degrees (WGS 84). + */ + lat: number; + /** + * Longitude in decimal degrees (WGS 84). + */ + lng: number; + }; + /** + * Destination category. + */ + destination_type?: 'beach' | 'mountain' | 'urban' | 'cultural' | 'adventure' | 'wellness' | 'cruise'; + price?: Price; + /** + * Destination hero image URL. + */ + image_url?: string; + /** + * Destination landing page or booking URL. + */ + url?: string; + /** + * Destination rating (1–5). + */ + rating?: number; + /** + * Tags for filtering (e.g., 'family', 'romantic', 'solo', 'winter-sun'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this destination. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (destination hero), 'images_vertical' (9:16 for Snap, Stories), 'images_square' (1:1). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} +/** + * Starting price for a trip to this destination. + */ +export interface Price { + /** + * Monetary amount in the specified currency. + */ + amount: number; + /** + * ISO 4217 currency code (e.g., 'USD', 'EUR', 'GBP'). + */ + currency: string; + /** + * Billing period. 'night' for hotel rates, 'month' or 'year' for salaries and rentals, 'one_time' for purchase prices. Omit when the period is obvious from context (e.g., a vehicle price is always one-time). + */ + period?: 'night' | 'month' | 'year' | 'one_time'; +} +/** + * A structured group of creative assets within an offering, identified by a group ID and asset type. Enables offerings to carry per-group creative pools (headlines, images, videos) using the same vocabulary as format-level asset definitions. + */ +export interface OfferingAssetGroup { + /** + * Identifies the creative role this group fills. Values are defined by each format's offering_asset_constraints — not protocol constants. Discover them via list_creative_formats (e.g., a format might declare 'headlines', 'images', or 'videos'). + */ + asset_group_id: string; + asset_type: AssetContentType; + /** + * The assets in this group. Each item should match the structure for the declared asset_type. Note: JSON Schema validation accepts any valid asset structure here; enforcement that items match asset_type is the responsibility of the consuming agent. + */ + items: ( + | TextAsset + | ImageAsset + | VideoAsset + | AudioAsset + | URLAsset + | HTMLAsset + | MarkdownAsset + | VASTAsset + | DAASTAsset + | CSSAsset + | JavaScriptAsset + | WebhookAsset + )[]; + ext?: ExtensionObject; +} + +// core/destination.json +/** + * A deployment target where signals can be activated (DSP, sales agent, etc.) + */ +export type Destination = + | { + /** + * Discriminator indicating this is a platform-based deployment + */ + type: 'platform'; + /** + * Platform identifier for DSPs (e.g., 'the-trade-desk', 'amazon-dsp') + */ + platform: string; + /** + * Optional account identifier on the platform + */ + account?: string; + } + | { + /** + * Discriminator indicating this is an agent URL-based deployment + */ + type: 'agent'; + /** + * URL identifying the deployment agent (for sales agents, etc.) + */ + agent_url: string; + /** + * Optional account identifier on the agent + */ + account?: string; + }; + + +// core/education-item.json +/** + * An educational program or course within an education-type catalog. Carries the program details that platforms use for education ads and student recruitment campaigns. Maps to Google DynamicEducationAsset, schema.org Course, and similar formats. + */ +export interface EducationItem { + /** + * Unique identifier for this program or course. + */ + program_id: string; + /** + * Program or course name (e.g., 'MSc Computer Science', 'Digital Marketing Certificate'). + */ + name: string; + /** + * Institution or provider name. + */ + school: string; + /** + * Program description including curriculum highlights and outcomes. + */ + description?: string; + /** + * Subject area or field of study (e.g., 'computer-science', 'business', 'healthcare'). + */ + subject?: string; + /** + * Type of credential awarded. + */ + degree_type?: 'certificate' | 'associate' | 'bachelor' | 'master' | 'doctorate' | 'professional' | 'bootcamp'; + /** + * Difficulty or prerequisite level. + */ + level?: 'beginner' | 'intermediate' | 'advanced'; + price?: Price; + /** + * Program duration as a human-readable string (e.g., '4 weeks', '2 years', '6 months'). + */ + duration?: string; + /** + * Next available start date (ISO 8601 date). + */ + start_date?: string; + /** + * Language of instruction (e.g., 'en', 'nl', 'es'). + */ + language?: string; + /** + * Delivery format. + */ + modality?: 'online' | 'in_person' | 'hybrid'; + /** + * Campus or instruction location (e.g., 'Amsterdam, NL'). Omit for fully online programs. + */ + location?: string; + /** + * Program or institution image URL. + */ + image_url?: string; + /** + * Program landing page or enrollment URL. + */ + url?: string; + /** + * Tags for filtering (e.g., 'stem', 'scholarship-available', 'evening-classes'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this program. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (campus/program hero), 'images_vertical' (9:16 for Stories), 'logo' (institution logo). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// core/event-custom-data.json +/** + * Event-specific data for attribution and reporting + */ +export interface EventCustomData { + /** + * Monetary value of the event (should be accompanied by currency) + */ + value?: number; + /** + * ISO 4217 currency code + */ + currency?: string; + /** + * Unique order or transaction identifier + */ + order_id?: string; + /** + * Item identifiers for catalog attribution. Values are matched against catalog items using the identifier type declared by the catalog's content_id_type field (e.g., SKUs, GTINs, or vertical-specific IDs like job_id). + */ + content_ids?: string[]; + /** + * Category of content associated with the event (e.g., 'product', 'job', 'hotel'). Corresponds to the catalog type when used for catalog attribution. + */ + content_type?: string; + /** + * Name of the product or content + */ + content_name?: string; + /** + * Category of the product or content + */ + content_category?: string; + /** + * Number of items in the event + */ + num_items?: number; + /** + * Search query for search events + */ + search_string?: string; + /** + * Per-item details for e-commerce events + */ + contents?: { + /** + * Product or content identifier + */ + id: string; + /** + * Quantity of this item + */ + quantity?: number; + /** + * Price per unit of this item + */ + price?: number; + /** + * Brand name of this item + */ + brand?: string; + }[]; + ext?: ExtensionObject; +} + +// core/event-source-health.json +/** + * Health assessment for a configured event source. Sellers evaluate the quality, completeness, and volume of events received from this source. Sellers with native quality scores (Snap EQS, Meta EMQ) relay them in detail; sellers without native scores derive status from operational metrics (volume, error rates, tag activity). + */ +export interface EventSourceHealth { + status: AssessmentStatus; + /** + * Seller-specific scoring detail. Only present when the seller has a native quality score to relay. Buyer agents should use status (not detail) for cross-seller decisions. Detail is supplementary context for human review or advanced diagnostics. + */ + detail?: { + /** + * Seller-defined quality score. Scale varies by seller — only compare within the same seller. + */ + score: number; + /** + * Maximum possible score on this seller's scale. + */ + max_score: number; + /** + * Seller's name for this score (e.g., 'Event Quality Score', 'Event Match Quality'). + */ + label?: string; + }; + /** + * Fraction of events from this source that the seller successfully matched to ad interactions (0.0-1.0). Low match rates indicate weak user_match identifiers. Absent when the seller does not compute match rates. + */ + match_rate?: number; + /** + * ISO 8601 timestamp of the most recent event received from this source. Absent when no events have been received. + */ + last_event_at?: string; + /** + * ISO 8601 timestamp of when this health assessment was computed. When health is derived from reporting data, this may lag real-time. Buyer agents can use this to decide whether to trust stale assessments or re-request. + */ + evaluated_at?: string; + /** + * Number of events received from this source in the last 24 hours. Zero indicates the source is configured but not firing. + */ + events_received_24h?: number; + /** + * Actionable issues detected with this event source. Sellers should limit to the top 3-5 most actionable items. Buyer agents should sort by severity rather than relying on array position. + */ + issues?: DiagnosticIssue[]; +} + +// core/event.json +/** + * User identifiers for attribution matching + */ +export type UserMatch = { + [k: string]: unknown | undefined; +} & { + /** + * Universal ID values for user matching + */ + uids?: { + type: UIDType; + /** + * Universal ID value + */ + value: string; + }[]; + /** + * SHA-256 hash of lowercase, trimmed email address. Buyer must normalize before hashing: lowercase, trim whitespace. + */ + hashed_email?: string; + /** + * SHA-256 hash of E.164-formatted phone number (e.g. +12065551234). Buyer must normalize to E.164 before hashing. + */ + hashed_phone?: string; + /** + * Platform click identifier (fbclid, gclid, ttclid, ScCid, etc.) + */ + click_id?: string; + /** + * Type of click identifier (e.g. fbclid, gclid, ttclid, msclkid, ScCid) + */ + click_id_type?: string; + /** + * Client IP address for probabilistic matching + */ + client_ip?: string; + /** + * Client user agent string for probabilistic matching + */ + client_user_agent?: string; + ext?: ExtensionObject; +}; +/** + * A marketing event (conversion, engagement, or custom) for attribution and optimization + */ +export interface Event { + /** + * Unique identifier for deduplication (scoped to event_type + event_source_id) + */ + event_id: string; + event_type: EventType; + /** + * ISO 8601 timestamp when the event occurred + */ + event_time: string; + user_match?: UserMatch; + custom_data?: EventCustomData; + action_source?: ActionSource; + /** + * URL where the event occurred (required when action_source is 'website') + */ + event_source_url?: string; + /** + * Name for custom events (used when event_type is 'custom') + */ + custom_event_name?: string; + ext?: ExtensionObject; +} + +// core/flight-item.json +/** + * A flight route within a flight-type catalog. Carries origin/destination, airline, pricing, and schedule data that platforms use for flight ads and dynamic travel remarketing. Maps to Google DynamicFlightsAsset, Meta flight catalogs, and similar formats. + */ +export interface FlightItem { + /** + * Unique identifier for this flight route or offer. + */ + flight_id: string; + /** + * Departure airport or city. + */ + origin: { + /** + * IATA airport code (e.g., 'AMS', 'JFK', 'LHR'). + */ + airport_code: string; + /** + * City name (e.g., 'Amsterdam', 'New York'). + */ + city?: string; + }; + /** + * Arrival airport or city. + */ + destination: { + /** + * IATA airport code. + */ + airport_code: string; + /** + * City name. + */ + city?: string; + }; + /** + * Airline name or IATA airline code. + */ + airline?: string; + price?: Price; + /** + * Route description or promotional text. + */ + description?: string; + /** + * Departure date and time (ISO 8601). + */ + departure_time?: string; + /** + * Arrival date and time (ISO 8601). + */ + arrival_time?: string; + /** + * Promotional image URL (typically a destination photo). + */ + image_url?: string; + /** + * Booking page URL for this route. + */ + url?: string; + /** + * Tags for filtering (e.g., 'direct', 'red-eye', 'business-class'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this flight. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (destination hero), 'images_vertical' (9:16 for Stories), 'images_square' (1:1). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// core/format.json +/** + * Types of parameters that template formats accept in format_id objects to create parameterized format identifiers + */ +export type FormatIDParameter = 'dimensions' | 'duration'; +/** + * WCAG conformance level that this format achieves. For format-rendered creatives, the format guarantees this level. For opaque creatives, the format requires assets that self-certify to this level. + */ +export type WCAGLevel = 'A' | 'AA' | 'AAA'; +/** + * Represents a creative format with its requirements + */ +export interface Format { + format_id: FormatID; + /** + * Human-readable format name + */ + name: string; + /** + * Plain text explanation of what this format does and what assets it requires + */ + description?: string; + /** + * Optional URL to showcase page with examples and interactive demos of this format + */ + example_url?: string; + /** + * List of parameters this format accepts in format_id. Template formats define which parameters (dimensions, duration, etc.) can be specified when instantiating the format. Empty or omitted means this is a concrete format with fixed parameters. + */ + accepts_parameters?: FormatIDParameter[]; + /** + * Specification of rendered pieces for this format. Most formats produce a single render. Companion ad formats (video + banner), adaptive formats, and multi-placement formats produce multiple renders. Each render specifies its role and dimensions. + */ + renders?: ( + | { + [k: string]: unknown | undefined; + } + | { + parameters_from_format_id: true; + } + )[]; + /** + * Array of all assets supported for this format. Each asset is identified by its asset_id, which must be used as the key in creative manifests. Use the 'required' boolean on each asset to indicate whether it's mandatory. + */ + assets?: ( + | BaseIndividualAsset + | { + /** + * Discriminator indicating this is a repeatable asset group + */ + item_type: 'repeatable_group'; + /** + * Identifier for this asset group (e.g., 'product', 'slide', 'card') + */ + asset_group_id: string; + /** + * Whether this asset group is required. If true, at least min_count repetitions must be provided. + */ + required: boolean; + /** + * Minimum number of repetitions required (if group is required) or allowed (if optional) + */ + min_count: number; + /** + * Maximum number of repetitions allowed + */ + max_count: number; + /** + * How the platform uses repetitions of this group. 'sequential' means all items display in order (carousels, playlists). 'optimize' means the platform selects the best-performing combination from alternatives (asset group optimization like Meta Advantage+ or Google Pmax). + */ + selection_mode?: 'sequential' | 'optimize'; + /** + * Assets within each repetition of this group + */ + assets: BaseGroupAsset[]; + } + )[]; + /** + * Delivery method specifications (e.g., hosted, VAST, third-party tags) + */ + delivery?: {}; + /** + * List of universal macros supported by this format (e.g., MEDIA_BUY_ID, CACHEBUSTER, DEVICE_ID). Used for validation and developer tooling. See docs/creative/universal-macros.mdx for full documentation. + */ + supported_macros?: (UniversalMacro | string)[]; + /** + * Array of format IDs this format accepts as input creative manifests. When present, indicates this format can take existing creatives in these formats as input. Omit for formats that work from raw assets (images, text, etc.) rather than existing creatives. + */ + input_format_ids?: FormatID[]; + /** + * Array of format IDs that this format can produce as output. When present, indicates this format can build creatives in these output formats (e.g., a multi-publisher template format might produce standard display formats across many publishers). Omit for formats that produce a single fixed output (the format itself). + */ + output_format_ids?: FormatID[]; + /** + * Optional standard visual card (300x400px) for displaying this format in user interfaces. Can be rendered via preview_creative or pre-generated. + */ + format_card?: { + format_id: FormatID; + /** + * Asset manifest for rendering the card, structure defined by the format + */ + manifest: {}; + }; + /** + * Accessibility posture of this format. Declares the WCAG conformance level that creatives produced by this format will meet. + */ + accessibility?: { + wcag_level: WCAGLevel; + /** + * When true, all assets with x-accessibility fields must include those fields. For inspectable assets (image, video, audio), this means providing accessibility metadata like alt_text or captions. For opaque assets (HTML, JavaScript), this means providing self-declared accessibility properties. + */ + requires_accessible_assets?: boolean; + }; + /** + * Disclosure positions this format can render. Buyers use this to determine whether a format can satisfy their compliance requirements before submitting a creative. When omitted, the format makes no disclosure rendering guarantees — creative agents SHOULD treat this as incompatible with briefs that require specific disclosure positions. Values correspond to positions on creative-brief.json required_disclosures. + */ + supported_disclosure_positions?: DisclosurePosition[]; + /** + * Structured disclosure capabilities per position with persistence modes. Declares which persistence behaviors each disclosure position supports, enabling persistence-aware matching against provenance render guidance and brief requirements. When present, supersedes supported_disclosure_positions for persistence-aware queries. The flat supported_disclosure_positions field is retained for backward compatibility. Each position MUST appear at most once; validators and agents SHOULD reject duplicates. + */ + disclosure_capabilities?: { + position: DisclosurePosition; + /** + * Persistence modes this position supports + */ + persistence: DisclosurePersistence[]; + }[]; + /** + * Optional detailed card with carousel and full specifications. Provides rich format documentation similar to ad spec pages. + */ + format_card_detailed?: { + format_id: FormatID; + /** + * Asset manifest for rendering the detailed card, structure defined by the format + */ + manifest: {}; + }; + /** + * Metrics this format can produce in delivery reporting. Buyers receive the intersection of format reported_metrics and product available_metrics. If omitted, the format defers entirely to product-level metric declarations. + */ + reported_metrics?: AvailableMetric[]; + /** + * Pricing options for this format. Used by transformation and generation agents that charge per format adapted, per image generated, or per unit of work. Present when the request included include_pricing=true and account. Ad servers and library-based agents expose pricing on list_creatives instead. + */ + pricing_options?: VendorPricingOption[]; +} +export interface BaseIndividualAsset { + /** + * Discriminator indicating this is an individual asset + */ + item_type: 'individual'; + /** + * Unique identifier for this asset. Creative manifests MUST use this exact value as the key in the assets object. + */ + asset_id: string; + /** + * Descriptive label for this asset's purpose (e.g., 'hero_image', 'logo', 'third_party_tracking'). For documentation and UI display only — manifests key assets by asset_id, not asset_role. + */ + asset_role?: string; + /** + * Whether this asset is required (true) or optional (false). Required assets must be provided for a valid creative. Optional assets enhance the creative but are not mandatory. + */ + required: boolean; + /** + * Publisher-controlled elements rendered on top of buyer content at this asset's position (e.g., video player controls, publisher logos). Creative agents should avoid placing critical content (CTAs, logos, key copy) within overlay bounds. + */ + overlays?: Overlay[]; +} +/** + * A publisher-controlled element that renders on top of buyer creative content within the ad placement. Creative agents should avoid placing critical content (CTAs, logos, key copy) within overlay bounds. + */ +export interface Overlay { + /** + * Identifier for this overlay (e.g., 'play_pause', 'volume', 'publisher_logo', 'carousel_prev', 'carousel_next') + */ + id: string; + /** + * Human-readable explanation of what this overlay is and how buyers should account for it + */ + description?: string; + /** + * Optional visual reference for this overlay element. Useful for creative agents compositing previews and for buyers understanding what will appear over their content. Must include at least one of: url, light, or dark. + */ + visual?: { + /** + * URL to a theme-neutral overlay graphic (SVG or PNG). Use when a single file works for all backgrounds, e.g. an SVG using CSS custom properties or currentColor. + */ + url?: string; + /** + * URL to the overlay graphic for use on light/bright backgrounds (SVG or PNG) + */ + light?: string; + /** + * URL to the overlay graphic for use on dark backgrounds (SVG or PNG) + */ + dark?: string; + }; + /** + * Position and size of the overlay relative to the asset's own top-left corner. See 'unit' for coordinate interpretation. + */ + bounds: { + /** + * Horizontal offset from the asset's left edge + */ + x: number; + /** + * Vertical offset from the asset's top edge + */ + y: number; + /** + * Width of the overlay + */ + width: number; + /** + * Height of the overlay + */ + height: number; + /** + * 'px' = absolute pixels from asset top-left. 'fraction' = proportional to asset dimensions (0.0 = edge, 1.0 = opposite edge). 'inches', 'cm', 'mm', 'pt' (1/72 inch) = physical units for print overlays, measured from asset top-left. + */ + unit: 'px' | 'fraction' | 'inches' | 'cm' | 'mm' | 'pt'; + }; +} +export interface BaseGroupAsset { + /** + * Identifier for this asset within the group + */ + asset_id: string; + /** + * Descriptive label for this asset's purpose. For documentation and UI display only — manifests key assets by asset_id, not asset_role. + */ + asset_role?: string; + /** + * Whether this asset is required within each repetition of the group + */ + required: boolean; + /** + * Publisher-controlled elements rendered on top of buyer content at this asset's position (e.g., carousel navigation arrows, slide indicators). Creative agents should avoid placing critical content within overlay bounds. + */ + overlays?: Overlay[]; +} + +// core/hotel-item.json +/** + * A hotel or lodging property within a hotel-type catalog. Carries the property data that platforms use for hotel ads, dynamic remarketing, and travel campaign creatives. Maps to Google Hotel Center feeds, Meta hotel catalogs, and similar platform-native formats. + */ +export interface HotelItem { + /** + * Unique identifier for this property. Used to match remarketing events and inventory feeds to the correct hotel. + */ + hotel_id: string; + /** + * Property name (e.g., 'Grand Hotel Amsterdam', 'Seaside Resort & Spa'). + */ + name: string; + /** + * Property description highlighting features and location. + */ + description?: string; + /** + * Geographic coordinates of the property. + */ + location: { + /** + * Latitude in decimal degrees (WGS 84). + */ + lat: number; + /** + * Longitude in decimal degrees (WGS 84). + */ + lng: number; + }; + /** + * Structured address for display and geocoding. + */ + address?: { + /** + * Street address. + */ + street?: string; + /** + * City name. + */ + city?: string; + /** + * State, province, or region. + */ + region?: string; + /** + * Postal or ZIP code. + */ + postal_code?: string; + /** + * ISO 3166-1 alpha-2 country code. + */ + country?: string; + }; + /** + * Official star rating (1–5). + */ + star_rating?: number; + price?: Price; + /** + * Primary property image URL. + */ + image_url?: string; + /** + * Property landing page or booking URL. + */ + url?: string; + /** + * Property phone number in E.164 format. + */ + phone?: string; + /** + * Property amenities (e.g., 'pool', 'wifi', 'spa', 'parking', 'restaurant'). + */ + amenities?: string[]; + /** + * Standard check-in time in HH:MM format (e.g., '15:00'). + */ + check_in_time?: string; + /** + * Standard check-out time in HH:MM format (e.g., '11:00'). + */ + check_out_time?: string; + /** + * Tags for filtering and targeting (e.g., 'boutique', 'family', 'business', 'luxury'). + */ + tags?: string[]; + /** + * Date from which this item is available or this rate applies (ISO 8601, e.g., '2025-03-01'). Used for seasonal availability windows in feed imports. + */ + valid_from?: string; + /** + * Date until which this item is available or this rate applies (ISO 8601, e.g., '2025-09-30'). Used for seasonal availability windows in feed imports. + */ + valid_to?: string; + /** + * Typed creative asset pools for this hotel. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (16:9 hero images), 'images_vertical' (9:16 for Snap, Stories), 'images_square' (1:1), 'logo'. Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// core/job-item.json +/** + * A job posting within a job-type catalog. Carries the position details that platforms use for job ads and recruitment campaigns. Maps to LinkedIn Jobs XML, Google DynamicJobsAsset, schema.org JobPosting, and similar formats. + */ +export interface JobItem { + /** + * Unique identifier for this job posting. + */ + job_id: string; + /** + * Job title (e.g., 'Senior Software Engineer', 'Marketing Manager'). + */ + title: string; + /** + * Hiring company or organization name. + */ + company_name: string; + /** + * Full job description including responsibilities and qualifications. + */ + description: string; + /** + * Job location as a display string (e.g., 'Amsterdam, NL', 'Remote', 'New York, NY'). Use 'Remote' for fully remote positions. + */ + location?: string; + /** + * Type of employment. + */ + employment_type?: 'full_time' | 'part_time' | 'contract' | 'temporary' | 'internship' | 'freelance'; + /** + * Required experience level. + */ + experience_level?: 'entry_level' | 'mid_level' | 'senior' | 'director' | 'executive'; + /** + * Salary range. Specify min and/or max with currency and period. + */ + salary?: { + /** + * Minimum salary. + */ + min?: number; + /** + * Maximum salary. + */ + max?: number; + /** + * ISO 4217 currency code. + */ + currency: string; + /** + * Pay period. + */ + period: 'hour' | 'month' | 'year'; + }; + /** + * Date the job was posted (ISO 8601 date). + */ + date_posted?: string; + /** + * Application deadline (ISO 8601 date). + */ + valid_through?: string; + /** + * Direct application URL. + */ + apply_url?: string; + /** + * Job function categories (e.g., 'engineering', 'marketing', 'sales', 'finance'). + */ + job_functions?: string[]; + /** + * Industry classifications (e.g., 'technology', 'healthcare', 'retail'). + */ + industries?: string[]; + /** + * Tags for filtering (e.g., 'remote', 'visa-sponsorship', 'equity'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this job. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (company/role hero), 'images_vertical' (9:16 for Stories), 'logo' (company logo). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// core/media-buy-features.json +/** + * Optional media-buy protocol features. Used in capability declarations (seller declares support) and product filters (buyer requires support). If a seller declares a feature as true, they MUST honor requests using that feature. + */ +export interface MediaBuyFeatures { + /** + * Supports creatives provided inline in create_media_buy requests + */ + inline_creative_management?: boolean; + /** + * Honors property_list parameter in get_products to filter results to buyer-approved properties + */ + property_list_filtering?: boolean; + /** + * Supports sync_catalogs task for catalog feed management with platform review and approval + */ + catalog_management?: boolean; + [k: string]: boolean | undefined; +} + + +// core/offering.json +/** + * A promotable offering from a brand. Can represent a campaign, product promotion, service, or any other thing the brand wants to make available. Offerings carry structured asset groups for creative assembly and can be promoted via traditional creatives or conversational SI experiences (via the brand's SI agent). + */ +export interface Offering { + /** + * Unique identifier for this offering. Used by hosts to reference specific offerings in si_get_offering calls. + */ + offering_id: string; + /** + * Human-readable offering name (e.g., 'Winter Sale', 'Free Trial', 'Enterprise Platform') + */ + name: string; + /** + * Description of what's being offered + */ + description?: string; + /** + * Short promotional tagline for the offering + */ + tagline?: string; + /** + * When the offering becomes available. If not specified, offering is immediately available. + */ + valid_from?: string; + /** + * When the offering expires. If not specified, offering has no expiration. + */ + valid_to?: string; + /** + * URL for checkout/purchase flow when the brand doesn't support agentic checkout. + */ + checkout_url?: string; + /** + * Landing page URL for this offering. For catalog-driven creatives, this is the per-item click-through destination that platforms map to the ad's link-out URL. Every offering in a catalog should have a landing_url unless the format provides its own destination logic. + */ + landing_url?: string; + /** + * Structured asset groups for this offering. Each group carries a typed pool of creative assets (headlines, images, videos, etc.) identified by a group ID that matches format-level vocabulary. + */ + assets?: OfferingAssetGroup[]; + /** + * Geographic scope of this offering. Declares where the offering is relevant — for location-specific offerings such as job vacancies, in-store promotions, or local events. Platforms use this to target geographically appropriate audiences and to filter out offerings irrelevant to a user's location. Uses the same geographic structures as targeting_overlay in create_media_buy. + */ + geo_targets?: { + /** + * Countries where this offering is relevant. ISO 3166-1 alpha-2 codes (e.g., 'US', 'NL', 'DE'). + */ + countries?: string[]; + /** + * Regions or states where this offering is relevant. ISO 3166-2 subdivision codes (e.g., 'NL-NH', 'US-CA'). + */ + regions?: string[]; + /** + * Metro areas where this offering is relevant. Each entry specifies the classification system and target values. + */ + metros?: { + system: MetroAreaSystem; + /** + * Metro codes within the system + */ + values: string[]; + }[]; + /** + * Postal areas where this offering is relevant. Each entry specifies the postal system and target values. + */ + postal_areas?: { + system: PostalCodeSystem; + /** + * Postal codes within the system + */ + values: string[]; + }[]; + }; + /** + * Keywords for matching this offering to user intent. Hosts use these for retrieval/relevance scoring. + */ + keywords?: string[]; + /** + * Categories this offering belongs to (e.g., 'measurement', 'identity', 'programmatic') + */ + categories?: string[]; + ext?: ExtensionObject; +} + +// core/performance-feedback.json +/** + * The business metric being measured + */ +export type MetricType = + | 'overall_performance' + | 'conversion_rate' + | 'brand_lift' + | 'click_through_rate' + | 'completion_rate' + | 'viewability' + | 'brand_safety' + | 'cost_efficiency'; +/** + * Source of the performance data + */ +export type FeedbackSource = + | 'buyer_attribution' + | 'third_party_measurement' + | 'platform_analytics' + | 'verification_partner'; + +/** + * Represents performance feedback data for a media buy or package + */ +export interface PerformanceFeedback { + /** + * Unique identifier for this performance feedback submission + */ + feedback_id: string; + /** + * Publisher's media buy identifier + */ + media_buy_id: string; + /** + * Specific package within the media buy (if feedback is package-specific) + */ + package_id?: string; + /** + * Specific creative asset (if feedback is creative-specific) + */ + creative_id?: string; + /** + * Time period for performance measurement + */ + measurement_period: { + /** + * ISO 8601 start timestamp for measurement period + */ + start: string; + /** + * ISO 8601 end timestamp for measurement period + */ + end: string; + }; + /** + * Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected) + */ + performance_index: number; + metric_type: MetricType; + feedback_source: FeedbackSource; + /** + * Processing status of the performance feedback + */ + status: 'accepted' | 'queued' | 'applied' | 'rejected'; + /** + * ISO 8601 timestamp when feedback was submitted + */ + submitted_at: string; + /** + * ISO 8601 timestamp when feedback was applied to optimization algorithms + */ + applied_at?: string; +} + + +// core/placement-definition.json +/** + * Canonical placement definition published in a publisher's adagents.json. Defines stable placement IDs that products can reuse and that authorization rules can reference. When a product reuses a registered placement_id, it is referring to this same semantic placement, not inventing a new one with the same ID. + */ +export type PlacementDefinition = { + [k: string]: unknown | undefined; +} & { + /** + * Stable placement identifier unique within this adagents.json file. + */ + placement_id: string; + /** + * Human-readable placement name (e.g., 'Homepage Banner', 'Pre-roll', 'Sponsored Listing Slot 1'). + */ + name: string; + /** + * Description of where and how this placement appears. + */ + description?: string; + /** + * Tags for grouping and querying placements across properties and products (e.g., 'homepage', 'native', 'premium', 'pre_roll'). + */ + tags?: string[]; + /** + * Property IDs in this adagents.json where this placement can appear. + */ + property_ids?: PropertyID[]; + /** + * Property tags in this adagents.json where this placement can appear. Useful for network-wide positions such as 'pre_roll' or 'homepage_native_feed'. + */ + property_tags?: PropertyTag[]; + /** + * Optional collection IDs in this adagents.json where this placement is valid. Use to narrow a placement to specific content programs carried on the selected properties. + */ + collection_ids?: string[]; + /** + * Optional format IDs supported by this placement across the scoped properties and collections. Lets buyers answer which formats are available on which placements without relying on product-local definitions alone. + */ + format_ids?: FormatID[]; + ext?: ExtensionObject; +}; + +// core/product-filters.json +/** + * Geographic targeting level (country, region, metro, postal_area) + */ +export type GeographicTargetingLevel = 'country' | 'region' | 'metro' | 'postal_area'; +/** + * Targeting constraint for a specific signal. Uses value_type as discriminator to determine the targeting expression format. + */ +export type SignalTargeting = + | { + signal_id: SignalID; + /** + * Discriminator for binary signals + */ + value_type: 'binary'; + /** + * Whether to include (true) or exclude (false) users matching this signal + */ + value: boolean; + } + | { + signal_id: SignalID; + /** + * Discriminator for categorical signals + */ + value_type: 'categorical'; + /** + * Values to target. Users with any of these values will be included. + */ + values: string[]; + } + | { + signal_id: SignalID; + /** + * Discriminator for numeric signals + */ + value_type: 'numeric'; + /** + * Minimum value (inclusive). Omit for no minimum. Must be <= max_value when both are provided. Should be >= signal's range.min if defined. + */ + min_value?: number; + /** + * Maximum value (inclusive). Omit for no maximum. Must be >= min_value when both are provided. Should be <= signal's range.max if defined. + */ + max_value?: number; + }; +/** + * Structured filters for product discovery + */ +export interface ProductFilters { + delivery_type?: DeliveryType; + exclusivity?: Exclusivity; + /** + * Filter by pricing availability: true = products offering fixed pricing (at least one option with fixed_price), false = products offering auction pricing (at least one option without fixed_price). Products with both fixed and auction options match both true and false. + */ + is_fixed_price?: boolean; + /** + * Filter by specific format IDs + */ + format_ids?: FormatID[]; + /** + * Only return products accepting IAB standard formats + */ + standard_formats_only?: boolean; + /** + * Minimum exposures/impressions needed for measurement validity + */ + min_exposures?: number; + /** + * Campaign start date (ISO 8601 date format: YYYY-MM-DD) for availability checks + */ + start_date?: string; + /** + * Campaign end date (ISO 8601 date format: YYYY-MM-DD) for availability checks + */ + end_date?: string; + /** + * Budget range to filter appropriate products + */ + budget_range?: { + [k: string]: unknown | undefined; + }; + /** + * Filter by country coverage using ISO 3166-1 alpha-2 codes (e.g., ['US', 'CA', 'GB']). Works for all inventory types. + */ + countries?: string[]; + /** + * Filter by region coverage using ISO 3166-2 codes (e.g., ['US-NY', 'US-CA', 'GB-SCT']). Use for locally-bound inventory (regional OOH, local TV) where products have region-specific coverage. + */ + regions?: string[]; + /** + * Filter by metro coverage for locally-bound inventory (radio, DOOH, local TV). Use when products have DMA/metro-specific coverage. For digital inventory where products have broad coverage, use required_geo_targeting instead to filter by seller capability. + */ + metros?: { + system: MetroAreaSystem; + /** + * Metro code within the system (e.g., '501' for NYC DMA) + */ + code: string; + }[]; + /** + * Filter by advertising channels (e.g., ['display', 'ctv', 'dooh']) + */ + channels?: MediaChannel[]; + /** + * @deprecated + * Deprecated: Use trusted_match filter instead. Filter to products executable through specific agentic ad exchanges. URLs are canonical identifiers. + */ + required_axe_integrations?: string[]; + /** + * Filter products by Trusted Match Protocol capabilities. Only products with matching TMP support are returned. + */ + trusted_match?: { + /** + * Filter to products with specific TMP providers and match types. Each entry identifies a provider by agent_url and optionally requires specific match capabilities. Products must match at least one entry. + */ + providers?: { + /** + * Provider's agent URL from the registry. + */ + agent_url: string; + /** + * When true, require this provider to support context match. + */ + context_match?: boolean; + /** + * When true, require this provider to support identity match. + */ + identity_match?: boolean; + }[]; + /** + * Filter to products supporting specific TMP response types (e.g., 'activation', 'creative', 'catalog_items'). Products must support at least one of the listed types. + */ + response_types?: TMPResponseType[]; + }; + required_features?: MediaBuyFeatures; + /** + * Filter to products from sellers supporting specific geo targeting capabilities. Each entry specifies a targeting level (country, region, metro, postal_area) and optionally a system for levels that have multiple classification systems. + */ + required_geo_targeting?: { + level: GeographicTargetingLevel; + /** + * Classification system within the level. Required for metro (e.g., 'nielsen_dma') and postal_area (e.g., 'us_zip'). Not applicable for country/region which use ISO standards. + */ + system?: string; + }[]; + /** + * Filter to products supporting specific signals from data provider catalogs. Products must have the requested signals in their data_provider_signals and signal_targeting_allowed must be true (or all signals requested). + */ + signal_targeting?: SignalTargeting[]; + /** + * Filter by postal area coverage for locally-bound inventory (direct mail, DOOH, local campaigns). Use when products have postal-area-specific coverage. For digital inventory where products have broad coverage, use required_geo_targeting instead to filter by seller capability. + */ + postal_areas?: { + system: PostalCodeSystem; + /** + * Postal codes within the system (e.g., ['10001', '10002'] for us_zip) + */ + values: string[]; + }[]; + /** + * Filter by proximity to geographic points. Returns products with inventory coverage near these locations. Follows the same format as the targeting overlay — each entry uses exactly one method: travel_time + transport_mode, radius, or geometry. For locally-bound inventory (DOOH, radio), filters to products with coverage in the area. For digital inventory, filters to products from sellers supporting geo_proximity targeting. + */ + geo_proximity?: { + [k: string]: unknown | undefined; + }[]; + /** + * Filter to products that can meet the buyer's performance standard requirements. Each entry specifies a metric, minimum threshold, and optionally a required vendor and standard. Products that cannot meet these thresholds or do not support the specified vendors are excluded. Use this to tell the seller upfront: 'I need DoubleVerify for viewability at 70% MRC.' + */ + required_performance_standards?: PerformanceStandard[]; + /** + * Filter by keyword relevance for search and retail media platforms. Returns products that support keyword targeting for these terms. Allows the sell-side agent to assess keyword availability and recommend appropriate products. Use match_type to indicate the desired precision. + */ + keywords?: { + /** + * The keyword to target + */ + keyword: string; + /** + * Desired match type: broad matches related queries, phrase matches queries containing the keyword phrase, exact matches the query exactly. Defaults to broad. + */ + match_type?: 'broad' | 'phrase' | 'exact'; + }[]; +} + +// core/protocol-envelope.json +/** + * Standard envelope structure for AdCP task responses. This envelope is added by the protocol layer (MCP, A2A, REST) and wraps the task-specific response payload. Task response schemas should NOT include these fields - they are protocol-level concerns. + */ +export interface ProtocolEnvelope { + /** + * Session/conversation identifier for tracking related operations across multiple task invocations. Managed by the protocol layer to maintain conversational context. + */ + context_id?: string; + /** + * Unique identifier for tracking asynchronous operations. Present when a task requires extended processing time. Used to query task status and retrieve results when complete. + */ + task_id?: string; + status: TaskStatus; + /** + * Human-readable summary of the task result. Provides natural language explanation of what happened, suitable for display to end users or for AI agent comprehension. Generated by the protocol layer based on the task response. + */ + message?: string; + /** + * ISO 8601 timestamp when the response was generated. Useful for debugging, logging, cache validation, and tracking async operation progress. + */ + timestamp?: string; + push_notification_config?: PushNotificationConfig; + /** + * Opaque governance context issued by a governance agent during check_governance. Buyers attach it to governed purchase requests (media buys, rights acquisitions, signal activations, creative services); sellers persist it and include it on all subsequent governance calls for that action's lifecycle. Neither buyers nor sellers interpret this value — only the governance agent that issued it. This is the primary correlation key for audit and reporting across the governance lifecycle. + */ + governance_context?: string; + /** + * The actual task-specific response data. This is the content defined in individual task response schemas (e.g., get-products-response.json, create-media-buy-response.json). Contains only domain-specific data without protocol-level fields. + */ + payload: {}; +} + +// core/real-estate-item.json +/** + * A property listing within a real-estate-type catalog. Carries the address, pricing, and specification data that platforms use for real estate ads and dynamic remarketing. Maps to Google DynamicRealEstateAsset, Meta home listing catalogs, and similar formats. + */ +export interface RealEstateItem { + /** + * Unique identifier for this property listing. + */ + listing_id: string; + /** + * Listing title (e.g., 'Spacious 3BR Apartment in Jordaan'). + */ + title: string; + /** + * Property address. + */ + address: { + /** + * Street address. + */ + street?: string; + /** + * City name. + */ + city?: string; + /** + * State, province, or region. + */ + region?: string; + /** + * Postal or ZIP code. + */ + postal_code?: string; + /** + * ISO 3166-1 alpha-2 country code. + */ + country?: string; + }; + price?: Price; + /** + * Type of property. + */ + property_type?: 'house' | 'apartment' | 'condo' | 'townhouse' | 'land' | 'commercial'; + /** + * Whether the property is for sale or rent. + */ + listing_type?: 'for_sale' | 'for_rent'; + /** + * Number of bedrooms. + */ + bedrooms?: number; + /** + * Number of bathrooms (e.g., 2.5 for two full and one half bath). + */ + bathrooms?: number; + /** + * Property size. + */ + area?: { + /** + * Area value. + */ + value: number; + /** + * Area unit. + */ + unit: 'sqft' | 'sqm'; + }; + /** + * Property description. + */ + description?: string; + /** + * Geographic coordinates of the property. + */ + location?: { + /** + * Latitude in decimal degrees (WGS 84). + */ + lat: number; + /** + * Longitude in decimal degrees (WGS 84). + */ + lng: number; + }; + /** + * Primary property image URL. + */ + image_url?: string; + /** + * Listing page URL. + */ + url?: string; + /** + * Neighborhood or area name. + */ + neighborhood?: string; + /** + * Year the property was built. + */ + year_built?: number; + /** + * Tags for filtering (e.g., 'garden', 'parking', 'renovated', 'waterfront'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this property listing. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (exterior/interior hero), 'images_vertical' (9:16 for Stories), 'images_square' (1:1). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// core/reporting-webhook.json +/** + * Webhook configuration for automated reporting delivery. Configures where and how campaign performance reports are sent. + */ +export interface ReportingWebhook { + /** + * Webhook endpoint URL for reporting notifications + */ + url: string; + /** + * Optional client-provided token for webhook validation. Echoed back in webhook payload to validate request authenticity. + */ + token?: string; + /** + * Authentication configuration for webhook delivery (A2A-compatible) + */ + authentication: { + /** + * Array of authentication schemes. Supported: ['Bearer'] for simple token auth, ['HMAC-SHA256'] for signature verification (recommended for production) + */ + schemes: AuthenticationScheme[]; + /** + * Credentials for authentication. For Bearer: token sent in Authorization header. For HMAC-SHA256: shared secret used to generate signature. Minimum 32 characters. Exchanged out-of-band during onboarding. + */ + credentials: string; + }; + /** + * Frequency for automated reporting delivery. Must be supported by all products in the media buy. + */ + reporting_frequency: 'hourly' | 'daily' | 'monthly'; + /** + * Optional list of metrics to include in webhook notifications. If omitted, all available metrics are included. Must be subset of product's available_metrics. + */ + requested_metrics?: AvailableMetric[]; +} + + +// core/requirements/asset-requirements.json +/** + * Technical requirements for creative assets. The applicable schema is determined by the sibling asset_type field. + */ +export type AssetRequirements = + | ImageAssetRequirements + | VideoAssetRequirements + | AudioAssetRequirements + | TextAssetRequirements + | MarkdownAssetRequirements + | HTMLAssetRequirements + | CSSAssetRequirements + | JavaScriptAssetRequirements + | VASTAssetRequirements + | DAASTAssetRequirements + | URLAssetRequirements + | WebhookAssetRequirements; +/** + * Unit of measurement for width/height values. Defaults to 'px' when absent. Print formats use 'inches' or 'cm'. + */ +export type DimensionUnit = 'px' | 'dp' | 'inches' | 'cm' | 'mm' | 'pt'; + +/** + * Requirements for image creative assets. These define the technical constraints for image files. + */ +export interface ImageAssetRequirements { + /** + * Minimum width. Interpretation depends on unit (default: pixels). For exact dimensions, set min_width = max_width. + */ + min_width?: number; + /** + * Maximum width. Interpretation depends on unit (default: pixels). For exact dimensions, set min_width = max_width. + */ + max_width?: number; + /** + * Minimum height. Interpretation depends on unit (default: pixels). For exact dimensions, set min_height = max_height. + */ + min_height?: number; + /** + * Maximum height. Interpretation depends on unit (default: pixels). For exact dimensions, set min_height = max_height. + */ + max_height?: number; + unit?: DimensionUnit; + /** + * Required aspect ratio (e.g., '16:9', '1:1', '1.91:1') + */ + aspect_ratio?: string; + /** + * Accepted image file formats + */ + formats?: ('jpg' | 'jpeg' | 'png' | 'gif' | 'webp' | 'svg' | 'avif' | 'tiff' | 'pdf' | 'eps')[]; + /** + * Minimum resolution in dots per inch. Always in DPI regardless of the dimension unit. Standard print requires 300 DPI, newspaper 150 DPI. + */ + min_dpi?: number; + /** + * Required bleed area beyond the trim size. The submitted image must be larger than the declared dimensions: total width = trim width + left bleed + right bleed, total height = trim height + top bleed + bottom bleed. For uniform bleed: total = trim + (2 * uniform). Uses the same unit as the parent dimensions. + */ + bleed?: + | { + /** + * Same bleed on all four sides + */ + uniform: number; + } + | { + top: number; + right: number; + bottom: number; + left: number; + }; + /** + * Required color space. Print typically requires CMYK. + */ + color_space?: 'rgb' | 'cmyk' | 'grayscale'; + /** + * Maximum file size in kilobytes + */ + max_file_size_kb?: number; + /** + * Whether the image must support transparency (requires PNG, WebP, or GIF) + */ + transparency_required?: boolean; + /** + * Whether animated images (GIF, animated WebP) are accepted + */ + animation_allowed?: boolean; + /** + * Maximum animation duration in milliseconds (if animation_allowed is true) + */ + max_animation_duration_ms?: number; + /** + * Maximum weight in grams for the finished physical piece (print inserts, flyers). Affects postage calculations and production constraints. Only applicable to print channels. + */ + max_weight_grams?: number; +} +/** + * Requirements for video creative assets. These define the technical constraints for video files. + */ +export interface VideoAssetRequirements { + /** + * Minimum width in pixels + */ + min_width?: number; + /** + * Maximum width in pixels + */ + max_width?: number; + /** + * Minimum height in pixels + */ + min_height?: number; + /** + * Maximum height in pixels + */ + max_height?: number; + /** + * Required aspect ratio (e.g., '16:9', '9:16') + */ + aspect_ratio?: string; + /** + * Minimum duration in milliseconds + */ + min_duration_ms?: number; + /** + * Maximum duration in milliseconds + */ + max_duration_ms?: number; + /** + * Accepted video container formats + */ + containers?: ('mp4' | 'webm' | 'mov' | 'avi' | 'mkv')[]; + /** + * Accepted video codecs + */ + codecs?: ('h264' | 'h265' | 'vp8' | 'vp9' | 'av1' | 'prores')[]; + /** + * Maximum file size in kilobytes + */ + max_file_size_kb?: number; + /** + * Minimum video bitrate in kilobits per second + */ + min_bitrate_kbps?: number; + /** + * Maximum video bitrate in kilobits per second + */ + max_bitrate_kbps?: number; + /** + * Accepted frame rates in frames per second (e.g., [24, 30, 60]) + */ + frame_rates?: number[]; + /** + * Whether the video must include an audio track + */ + audio_required?: boolean; + /** + * Required frame rate type. Broadcast and SSAI require constant frame rate for seamless splicing. + */ + frame_rate_type?: 'constant' | 'variable'; + /** + * Required scan type. Modern delivery requires progressive scan. + */ + scan_type?: 'progressive' | 'interlaced'; + /** + * Required GOP structure. SSAI and broadcast require closed GOPs for clean splice points. + */ + gop_type?: 'closed' | 'open'; + /** + * Minimum keyframe interval in seconds + */ + min_gop_interval_seconds?: number; + /** + * Maximum keyframe interval in seconds. SSAI typically requires 1-2 second intervals. + */ + max_gop_interval_seconds?: number; + /** + * Required moov atom position in MP4 container. 'start' enables progressive download without buffering the entire file. + */ + moov_atom_position?: 'start' | 'end'; + /** + * Accepted audio codecs (e.g., ['aac', 'pcm', 'ac3']) + */ + audio_codecs?: ('aac' | 'pcm' | 'ac3' | 'eac3' | 'mp3' | 'opus' | 'vorbis' | 'flac')[]; + /** + * Accepted audio sample rates in Hz (e.g., [44100, 48000]) + */ + audio_sample_rates?: number[]; + /** + * Accepted audio channel configurations + */ + audio_channels?: ('mono' | 'stereo' | '5.1' | '7.1')[]; + /** + * Target integrated loudness in LUFS (e.g., -24 for broadcast, -16 for streaming) + */ + loudness_lufs?: number; + /** + * Acceptable deviation from loudness_lufs target in dB (e.g., 2 means -22 to -26 LUFS for a -24 target) + */ + loudness_tolerance_db?: number; + /** + * Maximum true peak level in dBFS (e.g., -2 for broadcast) + */ + true_peak_dbfs?: number; +} +/** + * Requirements for audio creative assets. + */ +export interface AudioAssetRequirements { + /** + * Minimum duration in milliseconds + */ + min_duration_ms?: number; + /** + * Maximum duration in milliseconds + */ + max_duration_ms?: number; + /** + * Accepted audio file formats + */ + formats?: ('mp3' | 'aac' | 'wav' | 'ogg' | 'flac')[]; + /** + * Maximum file size in kilobytes + */ + max_file_size_kb?: number; + /** + * Accepted sample rates in Hz (e.g., [44100, 48000]) + */ + sample_rates?: number[]; + /** + * Accepted audio channel configurations + */ + channels?: ('mono' | 'stereo')[]; + /** + * Minimum audio bitrate in kilobits per second + */ + min_bitrate_kbps?: number; + /** + * Maximum audio bitrate in kilobits per second + */ + max_bitrate_kbps?: number; +} +/** + * Requirements for text creative assets such as headlines, body copy, and CTAs. + */ +export interface TextAssetRequirements { + /** + * Minimum character length + */ + min_length?: number; + /** + * Maximum character length + */ + max_length?: number; + /** + * Minimum number of lines + */ + min_lines?: number; + /** + * Maximum number of lines + */ + max_lines?: number; + /** + * Regex pattern defining allowed characters (e.g., '^[a-zA-Z0-9 .,!?-]+$') + */ + character_pattern?: string; + /** + * List of prohibited words or phrases + */ + prohibited_terms?: string[]; +} +/** + * Requirements for markdown creative assets. + */ +export interface MarkdownAssetRequirements { + /** + * Maximum character length + */ + max_length?: number; +} +/** + * Requirements for HTML creative assets. These define the execution environment constraints that the HTML must be compatible with. + */ +export interface HTMLAssetRequirements { + /** + * Maximum file size in kilobytes for the HTML asset + */ + max_file_size_kb?: number; + /** + * Sandbox environment the HTML must be compatible with. 'none' = direct DOM access, 'iframe' = standard iframe isolation, 'safeframe' = IAB SafeFrame container, 'fencedframe' = Privacy Sandbox fenced frame + */ + sandbox?: 'none' | 'iframe' | 'safeframe' | 'fencedframe'; + /** + * Whether the HTML creative can load external resources (scripts, images, fonts, etc.). When false, all resources must be inlined or bundled. + */ + external_resources_allowed?: boolean; + /** + * List of domains the HTML creative may reference for external resources. Only applicable when external_resources_allowed is true. + */ + allowed_external_domains?: string[]; +} +/** + * Requirements for CSS creative assets. + */ +export interface CSSAssetRequirements { + /** + * Maximum file size in kilobytes + */ + max_file_size_kb?: number; +} +/** + * Requirements for JavaScript creative assets. These define the execution environment constraints that the JavaScript must be compatible with. + */ +export interface JavaScriptAssetRequirements { + /** + * Maximum file size in kilobytes for the JavaScript asset + */ + max_file_size_kb?: number; + /** + * Required JavaScript module format. 'script' = classic script, 'module' = ES modules, 'iife' = immediately invoked function expression + */ + module_type?: 'script' | 'module' | 'iife'; + /** + * Whether the JavaScript must use strict mode + */ + strict_mode_required?: boolean; + /** + * Whether the JavaScript can load external resources dynamically + */ + external_resources_allowed?: boolean; + /** + * List of domains the JavaScript may reference for external resources. Only applicable when external_resources_allowed is true. + */ + allowed_external_domains?: string[]; +} +/** + * Requirements for VAST (Video Ad Serving Template) creative assets. + */ +export interface VASTAssetRequirements { + /** + * Required VAST version + */ + vast_version?: '2.0' | '3.0' | '4.0' | '4.1' | '4.2'; +} +/** + * Requirements for DAAST (Digital Audio Ad Serving Template) creative assets. + */ +export interface DAASTAssetRequirements { + /** + * Required DAAST version. DAAST 1.0 is the current IAB standard. + */ + daast_version?: '1.0'; +} +/** + * Requirements for URL assets such as click-through URLs, tracking pixels, and landing pages. + */ +export interface URLAssetRequirements { + /** + * Standard role for this URL asset. Use this to constrain which purposes are valid for this URL slot. Complements asset_role (which is a human-readable label) by providing a machine-readable enum. + */ + role?: + | 'clickthrough' + | 'landing_page' + | 'impression_tracker' + | 'click_tracker' + | 'viewability_tracker' + | 'third_party_tracker'; + /** + * Allowed URL protocols. HTTPS is recommended for all ad URLs. + */ + protocols?: ('https' | 'http')[]; + /** + * List of allowed domains for the URL + */ + allowed_domains?: string[]; + /** + * Maximum URL length in characters + */ + max_length?: number; + /** + * Whether the URL supports macro substitution (e.g., ${CACHEBUSTER}) + */ + macro_support?: boolean; +} +/** + * Requirements for webhook creative assets. + */ +export interface WebhookAssetRequirements { + /** + * Allowed HTTP methods + */ + methods?: ('GET' | 'POST')[]; +} + + +// core/requirements/catalog-field-binding.json +/** + * Maps a format template slot to a catalog item field or typed asset pool. The 'kind' field identifies the binding variant. All bindings are optional — agents can still infer mappings without them. + */ +export type CatalogFieldBinding = + | ScalarBinding + | AssetPoolBinding + | { + kind: 'catalog_group'; + /** + * The asset_group_id of a repeatable_group in the format's assets array. + */ + format_group_id: string; + /** + * Each repetition of the format's repeatable_group maps to one item from the catalog. + */ + catalog_item: true; + /** + * Scalar and asset pool bindings that apply within each repetition of the group. Nested catalog_group bindings are not permitted. + */ + per_item_bindings?: (ScalarBinding | AssetPoolBinding)[]; + ext?: ExtensionObject; + }; + +/** + * Maps an individual format asset to a catalog item field via dot-notation path. + */ +export interface ScalarBinding { + kind: 'scalar'; + /** + * The asset_id from the format's assets array. Identifies which individual template slot this binding applies to. + */ + asset_id: string; + /** + * Dot-notation path to the field on the catalog item (e.g., 'name', 'price.amount', 'location.city'). + */ + catalog_field: string; + ext?: ExtensionObject; +} +/** + * Maps an individual format asset to a typed asset pool on the catalog item (e.g., images_landscape, images_vertical, logo). The format slot receives the first item in the pool. + */ +export interface AssetPoolBinding { + kind: 'asset_pool'; + /** + * The asset_id from the format's assets array. Identifies which individual template slot this binding applies to. + */ + asset_id: string; + /** + * The asset_group_id on the catalog item's assets array to pull from (e.g., 'images_landscape', 'images_vertical', 'logo'). + */ + asset_group_id: string; + ext?: ExtensionObject; +} + + +// core/requirements/catalog-requirements.json +/** + * Format-level declaration of what catalog feeds a creative needs. Formats that render product listings, store locators, or promotional content declare which catalog types must be synced and what fields each catalog must provide. Buyers use this to ensure the right catalogs are synced before submitting creatives. + */ +export interface CatalogRequirements { + catalog_type: CatalogType; + /** + * Whether this catalog type must be present. When true, creatives using this format must reference a synced catalog of this type. + */ + required?: boolean; + /** + * Minimum number of items the catalog must contain for this format to render properly (e.g., a carousel might require at least 3 products) + */ + min_items?: number; + /** + * Maximum number of items the format can render. Items beyond this limit are ignored. Useful for fixed-slot layouts (e.g., a 3-product card) or feed-size constraints. + */ + max_items?: number; + /** + * Fields that must be present and non-empty on every item in the catalog. Field names are catalog-type-specific (e.g., 'title', 'price', 'image_url' for product catalogs; 'store_id', 'quantity' for inventory feeds). + */ + required_fields?: string[]; + /** + * Accepted feed formats for this catalog type. When specified, the synced catalog must use one of these formats. When omitted, any format is accepted. + */ + feed_formats?: FeedFormat[]; + /** + * Per-item creative asset requirements. Declares what asset groups (headlines, images, videos) each catalog item must provide in its assets array, along with count bounds and per-asset technical constraints. Applicable to 'offering' and all vertical catalog types (hotel, flight, job, etc.) whose items carry typed assets. + */ + offering_asset_constraints?: OfferingAssetConstraint[]; + /** + * Explicit mappings from format template slots to catalog item fields or typed asset pools. Optional — creative agents can infer mappings without them, but bindings make the relationship self-describing and enable validation. Covers scalar fields (asset_id → catalog_field), asset pools (asset_id → asset_group_id on the catalog item), and repeatable groups that iterate over catalog items. + */ + field_bindings?: CatalogFieldBinding[]; +} +/** + * Declares per-group creative requirements that each offering must satisfy. Allows formats to specify what asset groups (headlines, images, videos) offerings must provide, along with count and per-asset technical constraints. + */ +export interface OfferingAssetConstraint { + /** + * The asset group this constraint applies to. Values are format-defined vocabulary — each format chooses its own group IDs (e.g., 'headlines', 'images', 'videos'). Buyers discover them via list_creative_formats. + */ + asset_group_id: string; + asset_type: AssetContentType; + /** + * Whether this asset group must be present in each offering. Defaults to true. + */ + required?: boolean; + /** + * Minimum number of items required in this group. + */ + min_count?: number; + /** + * Maximum number of items allowed in this group. + */ + max_count?: number; + asset_requirements?: AssetRequirements; + ext?: ExtensionObject; +} + +// core/response.json +/** + * Protocol-level response wrapper (MCP/A2A) - contains AdCP task data plus protocol fields + */ +export interface ProtocolResponse { + /** + * Human-readable summary + */ + message: string; + /** + * Session continuity identifier + */ + context_id?: string; + /** + * AdCP task-specific response data (see individual task response schemas) + */ + data?: { + [k: string]: unknown | undefined; + }; +} + + +// core/signal-definition.json +/** + * The data type of this signal's values + */ +export type SignalValueType = 'binary' | 'categorical' | 'numeric'; +/** + * Personal data categories that may be restricted from use in audience targeting. Based on GDPR Article 9 special categories of personal data, which are also referenced by EU DSA Article 26 for advertising restrictions. Used in two places: (1) on campaign plans via restricted_attributes to declare which categories are prohibited, and (2) on signal-definition.json via restricted_attributes to declare which categories a signal touches. Governance agents match plan restrictions against signal declarations for structural validation. + */ +export type RestrictedAttribute = + | 'racial_ethnic_origin' + | 'political_opinions' + | 'religious_beliefs' + | 'trade_union_membership' + | 'health_data' + | 'sex_life_sexual_orientation' + | 'genetic_data' + | 'biometric_data'; + +/** + * Definition of a signal in a data provider's catalog, published via adagents.json + */ +export interface SignalDefinition { + /** + * Signal identifier within this data provider's catalog + */ + id: string; + /** + * Human-readable signal name + */ + name: string; + /** + * Detailed description of what this signal represents and how it's derived + */ + description?: string; + value_type: SignalValueType; + /** + * Tags for grouping and filtering signals within the catalog + */ + tags?: string[]; + /** + * For categorical signals, the valid values users can be assigned + */ + allowed_values?: string[]; + /** + * Restricted attribute categories this signal touches. Data providers SHOULD declare these so governance agents can structurally match signals against a plan's restricted_attributes without relying on semantic inference from the signal name or description. + */ + restricted_attributes?: RestrictedAttribute[]; + /** + * Policy categories this signal is sensitive for (e.g., a children's interest signal declares ['children_directed']). Governance agents match these against a plan's policy_categories to flag sensitive data usage. + */ + policy_categories?: string[]; + /** + * For numeric signals, the valid value range + */ + range?: { + /** + * Minimum value + */ + min: number; + /** + * Maximum value + */ + max: number; + /** + * Unit of measurement (e.g., 'score', 'dollars', 'years') + */ + unit?: string; + }; +} + + +// core/signal-filters.json +/** + * Types of signal catalogs available for audience targeting + */ +export type SignalCatalogType = 'marketplace' | 'custom' | 'owned'; + +/** + * Filters to refine signal discovery results + */ +export interface SignalFilters { + /** + * Filter by catalog type + */ + catalog_types?: SignalCatalogType[]; + /** + * Filter by specific data providers + */ + data_providers?: string[]; + /** + * Maximum CPM filter. Applies only to signals with model='cpm'. + */ + max_cpm?: number; + /** + * Maximum percent-of-media rate filter. Signals where all percent_of_media pricing options exceed this value are excluded. Does not account for max_cpm caps. + */ + max_percent?: number; + /** + * Minimum coverage requirement + */ + min_coverage_percentage?: number; +} + + +// core/signal-pricing-option.json +/** + * Deprecated — use vendor-pricing-option.json for new implementations. This alias is retained for backward compatibility. + */ +export type SignalPricingOption = { + /** + * Opaque identifier for this pricing option, unique within the vendor agent. Pass this in report_usage to identify which pricing option was applied. + */ + pricing_option_id: string; +} & VendorPricing; + +// core/start-timing.json +/** + * Campaign start timing: 'asap' or ISO 8601 date-time + */ +export type StartTiming = 'asap' | string; + + +// core/store-item.json +/** + * A physical store or location within a store-type catalog. Carries the location data, catchment areas, and metadata that platforms use for proximity targeting, store locator creatives, and inventory-aware ad serving. + */ +export interface StoreItem { + /** + * Unique identifier for this store. Used to reference specific stores in targeting, inventory feeds, and creative templates. + */ + store_id: string; + /** + * Human-readable store name (e.g., 'Amsterdam Flagship', 'Brooklyn Heights'). + */ + name: string; + /** + * Geographic coordinates of the store. + */ + location: { + /** + * Latitude in decimal degrees (WGS 84). + */ + lat: number; + /** + * Longitude in decimal degrees (WGS 84). + */ + lng: number; + }; + /** + * Structured address for display and geocoding fallback. + */ + address?: { + /** + * Street address (e.g., '123 Main St'). + */ + street?: string; + /** + * City name. + */ + city?: string; + /** + * State, province, or region. ISO 3166-2 subdivision code preferred (e.g., 'NL-NH', 'US-CA'). + */ + region?: string; + /** + * Postal or ZIP code. + */ + postal_code?: string; + /** + * ISO 3166-1 alpha-2 country code. + */ + country?: string; + }; + /** + * Catchment areas for this store. Each defines a reachable area using travel time (isochrone), simple radius, or pre-computed GeoJSON. Multiple catchments allow different modes — e.g., 15-minute drive AND 10-minute walk. + */ + catchments?: Catchment[]; + /** + * Store phone number in E.164 format (e.g., '+31201234567'). + */ + phone?: string; + /** + * Store-specific page URL (e.g., store locator detail page). + */ + url?: string; + /** + * Operating hours. Keys are ISO day names (monday–sunday), values are time ranges. + */ + hours?: { + /** + * Time range in HH:MM-HH:MM format (e.g., '09:00-21:00'). Use 'closed' for days the store is not open. + */ + [k: string]: string | undefined; + }; + /** + * Tags for filtering stores in targeting and creative selection (e.g., 'flagship', 'pickup', 'pharmacy'). + */ + tags?: string[]; + ext?: ExtensionObject; +} + +// core/vehicle-item.json +/** + * A vehicle listing within a vehicle-type catalog. Carries the make/model, pricing, and specification data that platforms use for automotive inventory ads. Maps to Meta Automotive Inventory Ads, Microsoft Auto Inventory feeds, Google vehicle ads, and similar formats. + */ +export interface VehicleItem { + /** + * Unique identifier for this vehicle listing. + */ + vehicle_id: string; + /** + * Listing title (e.g., '2024 Honda Civic EX Sedan'). + */ + title: string; + /** + * Vehicle manufacturer (e.g., 'Honda', 'Ford', 'BMW'). + */ + make: string; + /** + * Vehicle model (e.g., 'Civic', 'F-150', 'X5'). + */ + model: string; + /** + * Model year. + */ + year: number; + price?: Price; + /** + * Vehicle condition. + */ + condition?: 'new' | 'used' | 'certified_pre_owned'; + /** + * Vehicle Identification Number (17-character VIN). + */ + vin?: string; + /** + * Trim level (e.g., 'EX', 'Limited', 'Sport'). + */ + trim?: string; + /** + * Odometer reading. + */ + mileage?: { + /** + * Mileage value. + */ + value: number; + /** + * Distance unit. + */ + unit: 'km' | 'mi'; + }; + /** + * Vehicle body style. + */ + body_style?: 'sedan' | 'suv' | 'truck' | 'coupe' | 'convertible' | 'wagon' | 'van' | 'hatchback'; + /** + * Transmission type. + */ + transmission?: 'automatic' | 'manual' | 'cvt'; + /** + * Fuel or powertrain type. + */ + fuel_type?: 'gasoline' | 'diesel' | 'electric' | 'hybrid' | 'plug_in_hybrid'; + /** + * Exterior color. + */ + exterior_color?: string; + /** + * Interior color. + */ + interior_color?: string; + /** + * Dealer or vehicle location. + */ + location?: { + /** + * Latitude in decimal degrees (WGS 84). + */ + lat: number; + /** + * Longitude in decimal degrees (WGS 84). + */ + lng: number; + }; + /** + * Primary vehicle image URL. + */ + image_url?: string; + /** + * Vehicle listing page URL. + */ + url?: string; + /** + * Tags for filtering (e.g., 'low-mileage', 'one-owner', 'dealer-certified'). + */ + tags?: string[]; + /** + * Typed creative asset pools for this vehicle. Uses the same OfferingAssetGroup structure as offering-type catalogs. Standard group IDs: 'images_landscape' (exterior hero), 'images_vertical' (9:16 for Stories), 'images_square' (1:1). Enables formats to declare typed image requirements that map unambiguously to the right asset regardless of platform. + */ + assets?: OfferingAssetGroup[]; + ext?: ExtensionObject; +} + +// creative/creative-feature-result.json +/** + * A single feature evaluation result for a creative. Uses the same value structure as property-feature-value (value, confidence, expires_at, etc.). + */ +export interface CreativeFeatureResult { + /** + * The feature that was evaluated (e.g., 'auto_redirect', 'brand_consistency'). Features prefixed with 'registry:' reference standardized policies from the shared policy registry (e.g., 'registry:eu_ai_act_article_50'). Unprefixed feature IDs are agent-defined. + */ + feature_id: string; + /** + * The feature value. Type depends on feature definition: boolean for binary, number for quantitative, string for categorical. + */ + value: boolean | number | string; + /** + * Unit of measurement for quantitative values (e.g., 'percentage', 'score') + */ + unit?: string; + /** + * Confidence score for this value (0-1) + */ + confidence?: number; + /** + * When this feature was evaluated + */ + measured_at?: string; + /** + * When this evaluation expires and should be refreshed + */ + expires_at?: string; + /** + * Version of the methodology used to evaluate this feature + */ + methodology_version?: string; + /** + * Additional vendor-specific details about this evaluation + */ + details?: {}; + ext?: ExtensionObject; +} + +// enums/advertiser-industry.json +/** + * Standardized advertiser industry classification. Top-level categories classify the advertiser's primary business. Dot-notation subcategories (e.g., 'media_entertainment.podcasts') provide platform-specific precision where needed. Sellers map these to platform-native codes (Spotify ADV categories, LinkedIn industry IDs, IAB Content Taxonomy, etc.). Sellers MUST accept unknown values gracefully — treat unrecognized values as the parent category (strip the subcategory) or as uncategorized. This ensures forward compatibility as the taxonomy evolves. + */ +export type AdvertiserIndustry = + | 'automotive' + | 'automotive.electric_vehicles' + | 'automotive.parts_accessories' + | 'automotive.luxury' + | 'beauty_cosmetics' + | 'beauty_cosmetics.skincare' + | 'beauty_cosmetics.fragrance' + | 'beauty_cosmetics.haircare' + | 'cannabis' + | 'cpg' + | 'cpg.personal_care' + | 'cpg.household' + | 'dating' + | 'education' + | 'education.higher_education' + | 'education.online_learning' + | 'education.k12' + | 'energy_utilities' + | 'energy_utilities.renewable' + | 'fashion_apparel' + | 'fashion_apparel.luxury' + | 'fashion_apparel.sportswear' + | 'finance' + | 'finance.banking' + | 'finance.insurance' + | 'finance.investment' + | 'finance.cryptocurrency' + | 'food_beverage' + | 'food_beverage.alcohol' + | 'food_beverage.restaurants' + | 'food_beverage.packaged_goods' + | 'gambling_betting' + | 'gambling_betting.sports_betting' + | 'gambling_betting.casino' + | 'gaming' + | 'gaming.mobile' + | 'gaming.console_pc' + | 'gaming.esports' + | 'government_nonprofit' + | 'government_nonprofit.political' + | 'government_nonprofit.charity' + | 'healthcare' + | 'healthcare.pharmaceutical' + | 'healthcare.medical_devices' + | 'healthcare.wellness' + | 'home_garden' + | 'home_garden.furniture' + | 'home_garden.home_improvement' + | 'media_entertainment' + | 'media_entertainment.podcasts' + | 'media_entertainment.music' + | 'media_entertainment.film_tv' + | 'media_entertainment.publishing' + | 'media_entertainment.live_events' + | 'pets' + | 'professional_services' + | 'professional_services.legal' + | 'professional_services.consulting' + | 'real_estate' + | 'real_estate.residential' + | 'real_estate.commercial' + | 'recruitment_hr' + | 'retail' + | 'retail.ecommerce' + | 'retail.department_stores' + | 'sports_fitness' + | 'sports_fitness.equipment' + | 'sports_fitness.teams_leagues' + | 'technology' + | 'technology.software' + | 'technology.hardware' + | 'technology.ai_ml' + | 'telecom' + | 'telecom.mobile_carriers' + | 'telecom.internet_providers' + | 'transportation_logistics' + | 'travel_hospitality' + | 'travel_hospitality.airlines' + | 'travel_hospitality.hotels' + | 'travel_hospitality.cruise' + | 'travel_hospitality.tourism'; + + +// enums/audience-source.json +/** + * Origin of an audience segment in delivery reporting breakdowns. Only 'synced' audiences are directly targetable via the targeting overlay; other sources are informational. + */ +export type AudienceSource = 'synced' | 'platform' | 'third_party' | 'lookalike' | 'retargeting' | 'unknown'; + + +// enums/brand-agent-type.json +/** + * Functional roles for agents declared in brand.json. Each type represents a distinct capability that a brand or house can expose via an agent endpoint. + */ +export type BrandAgentType = + | 'brand' + | 'rights' + | 'measurement' + | 'governance' + | 'creative' + | 'sales' + | 'buying' + | 'signals'; + + +// enums/budget-authority-level.json +/** + * The level of autonomy an agent has over budget decisions within a campaign plan. + */ +export type BudgetAuthorityLevel = 'agent_full' | 'agent_limited' | 'human_required'; + + +// enums/consent-basis.json +/** + * Common GDPR lawful bases relevant to advertising. Covers the Article 6(1) bases used in programmatic advertising contexts. + */ +export type ConsentBasis = 'consent' | 'legitimate_interest' | 'contract' | 'legal_obligation'; + + +// enums/creative-agent-capability.json +/** + * Capabilities supported by creative agents for format handling + */ +export type CreativeAgentCapability = 'validation' | 'assembly' | 'generation' | 'preview' | 'delivery'; + + +// enums/creative-approval-status.json +/** + * Approval state of a creative on a specific package + */ +export type CreativeApprovalStatus = 'pending_review' | 'approved' | 'rejected'; + + +// enums/creative-quality.json +/** + * Quality tier for creative generation, controlling the fidelity and cost tradeoff + */ +export type CreativeQuality = 'draft' | 'production'; + + +// enums/creative-sort-field.json +/** + * Fields available for sorting creative library listings + */ +export type CreativeSortField = 'created_date' | 'updated_date' | 'name' | 'status' | 'assignment_count'; + + +// enums/delegation-authority.json +/** + * Authority level granted to a delegated agent operating against a campaign plan. + */ +export type DelegationAuthority = 'full' | 'execute_only' | 'propose_only'; + + +// enums/error-code.json +/** + * Standard error code vocabulary for AdCP. Codes are machine-readable so agents can apply autonomous recovery strategies based on the recovery classification. Sellers MAY return codes not listed here for platform-specific errors — the error.json code field accepts any string. Agents MUST handle unknown codes by falling back to the recovery classification. + */ +export type ErrorCode = + | 'INVALID_REQUEST' + | 'AUTH_REQUIRED' + | 'RATE_LIMITED' + | 'SERVICE_UNAVAILABLE' + | 'POLICY_VIOLATION' + | 'PRODUCT_NOT_FOUND' + | 'PRODUCT_UNAVAILABLE' + | 'PROPOSAL_EXPIRED' + | 'BUDGET_TOO_LOW' + | 'CREATIVE_REJECTED' + | 'UNSUPPORTED_FEATURE' + | 'AUDIENCE_TOO_SMALL' + | 'ACCOUNT_NOT_FOUND' + | 'ACCOUNT_SETUP_REQUIRED' + | 'ACCOUNT_AMBIGUOUS' + | 'ACCOUNT_PAYMENT_REQUIRED' + | 'ACCOUNT_SUSPENDED' + | 'COMPLIANCE_UNSATISFIED' + | 'BUDGET_EXHAUSTED' + | 'BUDGET_EXCEEDED' + | 'CONFLICT' + | 'CREATIVE_DEADLINE_EXCEEDED' + | 'INVALID_STATE' + | 'MEDIA_BUY_NOT_FOUND' + | 'NOT_CANCELLABLE' + | 'PACKAGE_NOT_FOUND' + | 'SESSION_NOT_FOUND' + | 'SESSION_TERMINATED' + | 'VALIDATION_ERROR' + | 'PRODUCT_EXPIRED' + | 'PROPOSAL_NOT_COMMITTED' + | 'IO_REQUIRED' + | 'TERMS_REJECTED' + | 'VERSION_UNSUPPORTED'; + + +// enums/escalation-severity.json +/** + * The severity level of a governance escalation. + */ +export type EscalationSeverity = 'info' | 'warning' | 'critical'; + + +// enums/forecastable-metric.json +/** + * Standard delivery and engagement metric names for forecasts. For outcome/conversion forecasts (purchases, leads, app installs, etc.), use event-type enum values as metric keys instead. The ForecastPoint metrics map accepts any string key, so both forecastable-metric and event-type values can be used together. + */ +export type ForecastableMetric = + | 'audience_size' + | 'reach' + | 'frequency' + | 'impressions' + | 'clicks' + | 'spend' + | 'views' + | 'completed_views' + | 'grps' + | 'engagements' + | 'follows' + | 'saves' + | 'profile_visits' + | 'measured_impressions' + | 'downloads' + | 'plays'; + + +// enums/frequency-cap-scope.json +/** + * Scope for frequency cap application + */ +export type FrequencyCapScope = 'package'; + + +// enums/governance-domain.json +/** + * Governance sub-domains that a registry policy applies to. Used to indicate which types of governance agents can evaluate this policy. + */ +export type GovernanceDomain = 'campaign' | 'property' | 'creative' | 'content_standards'; + + +// enums/governance-mode.json +/** + * Operating mode for a governance agent. Controls whether findings block execution. + */ +export type GovernanceMode = 'audit' | 'advisory' | 'enforce'; + + +// enums/governance-phase.json +/** + * The phase of the governed action's lifecycle that triggered the governance check. + */ +export type GovernancePhase = 'purchase' | 'modification' | 'delivery'; + + +// enums/history-entry-type.json +/** + * Type of entry in task execution history + */ +export type HistoryEntryType = 'request' | 'response'; + + +// enums/match-id-type.json +/** + * Identifier types for audience match reporting. Combines hashed PII types (from audience-member.json field names) with universal ID types (from uid-type.json). + */ +export type MatchIDType = + | 'hashed_email' + | 'hashed_phone' + | 'rampid' + | 'id5' + | 'uid2' + | 'euid' + | 'pairid' + | 'maid' + | 'other'; + + +// enums/notification-type.json +/** + * Type of delivery notification for media buy reporting + */ +export type NotificationType = 'scheduled' | 'final' | 'delayed' | 'adjusted'; + + +// enums/outcome-type.json +/** + * The type of outcome reported to a campaign governance agent after a seller interaction. + */ +export type OutcomeType = 'completed' | 'failed' | 'delivery'; + + +// enums/policy-category.json +/** + * The nature of the obligation a policy represents. + */ +export type PolicyCategory = 'regulation' | 'standard'; + + +// enums/policy-enforcement.json +/** + * How governance agents treat violations of a policy. Uses RFC 2119 keywords. + */ +export type PolicyEnforcementLevel = 'must' | 'should' | 'may'; + + +// enums/preview-output-format.json +/** + * Output format for creative previews + */ +export type PreviewOutputFormat = 'url' | 'html'; + + +// enums/publisher-identifier-types.json +/** + * Valid identifier types for publisher/legal entity identification + */ +export type PublisherIdentifierTypes = 'tag_id' | 'duns' | 'lei' | 'seller_id' | 'gln'; + + +// enums/purchase-type.json +/** + * The type of financial commitment being governed. + */ +export type PurchaseType = 'media_buy' | 'rights_license' | 'signal_activation' | 'creative_services'; + + +// enums/si-session-status.json +/** + * State of a Sponsored Intelligence session between a host and a brand agent + */ +export type SISessionStatus = 'active' | 'pending_handoff' | 'complete' | 'terminated'; + + +// enums/signal-source.json +/** + * Source type for signal identifiers. Determines how the signal is referenced and whether authorization can be externally verified. + */ +export type SignalSource = 'catalog' | 'agent'; + + +// enums/sort-direction.json +/** + * Sort direction for list queries + */ +export type SortDirection = 'asc' | 'desc'; + + +// enums/sort-metric.json +/** + * Numeric delivery metrics available for sorting breakdown rows. Subset of delivery-metrics fields that are flat numeric values (excludes nested objects like quartile_data, dooh_metrics, viewability, by_event_type, by_action_source). + */ +export type SortMetric = + | 'impressions' + | 'spend' + | 'clicks' + | 'ctr' + | 'views' + | 'completed_views' + | 'completion_rate' + | 'conversions' + | 'conversion_value' + | 'roas' + | 'cost_per_acquisition' + | 'new_to_brand_rate' + | 'leads' + | 'grps' + | 'reach' + | 'frequency' + | 'engagements' + | 'follows' + | 'saves' + | 'profile_visits' + | 'engagement_rate' + | 'cost_per_click'; + + +// enums/validation-mode.json +/** + * Creative validation strictness levels + */ +export type ValidationMode = 'strict' | 'lenient'; + + +// extensions/extension-meta.json +/** + * Schema that all extension files must follow. Combines metadata (valid_from, docs_url) with the actual extension data schema. Extensions are auto-discovered from /schemas/extensions/*.json and included in versioned builds based on valid_from/valid_until. + */ +export interface AdCPExtensionFileSchema { + $schema: 'http://json-schema.org/draft-07/schema#'; + /** + * Extension ID following pattern /schemas/extensions/{namespace}.json + */ + $id: string; + /** + * Human-readable title for the extension + */ + title: string; + /** + * Description of what this extension provides + */ + description: string; + /** + * Minimum AdCP version this extension is compatible with (e.g., '2.5'). Extension will be included in all versioned schema builds >= this version. + */ + valid_from: string; + /** + * Last AdCP version this extension is compatible with (e.g., '3.0'). Omit if extension is still valid for current and future versions. + */ + valid_until?: string; + /** + * URL to documentation for implementors of this extension + */ + docs_url?: string; + /** + * Extensions must be objects (data within ext.{namespace}) + */ + type: 'object'; + /** + * Schema properties defining the structure of ext.{namespace} data + */ + properties: {}; + /** + * Required properties within the extension data + */ + required?: string[]; + /** + * Whether additional properties are allowed in the extension data + */ + additionalProperties?: { + [k: string]: unknown | undefined; + }; +} + + +// governance/audience-constraints.json +/** + * Buyer-defined audience targeting constraints for a campaign plan. Specifies who the campaign should and should not reach. The governance agent evaluates seller targeting against these constraints during check_governance. + */ +export interface AudienceConstraints { + /** + * Desired audience criteria. The seller's targeting should align with these. Each criterion is evaluated independently — the combined targeting should satisfy at least one inclusion criterion. + */ + include?: AudienceSelector[]; + /** + * Excluded audience criteria. The seller's targeting must not overlap with these. Exclusions take precedence over inclusions. Used for protected groups, vulnerable communities, regulatory restrictions, or brand safety. + */ + exclude?: AudienceSelector[]; +} + + +// governance/policy-entry.json +/** + * A complete policy in the policy registry. Policies use natural language text evaluated by governance agents (LLMs), following the same pattern as Content Standards. The registry's value is in structured metadata (jurisdiction, policy category, source, enforcement level) and calibration exemplars. + */ +export interface PolicyEntry { + /** + * Unique identifier for this policy (e.g., "uk_hfss", "us_coppa", "alcohol_advertising"). + */ + policy_id: string; + /** + * Semver version string (e.g., "1.0.0"). Incremented when policy content changes. + */ + version: string; + /** + * Human-readable name (e.g., "UK HFSS Restrictions"). + */ + name: string; + /** + * Brief summary of what this policy covers. + */ + description?: string; + category: PolicyCategory; + enforcement: PolicyEnforcementLevel; + /** + * ISO 3166-1 alpha-2 country codes where this policy applies. Empty array means the policy is not jurisdiction-specific. + */ + jurisdictions?: string[]; + /** + * Named groups of jurisdictions for convenience (e.g., {"EU": ["AT","BE","BG",...]}). Governance agents expand aliases when matching against a plan's target jurisdictions. + */ + region_aliases?: { + [k: string]: string[] | undefined; + }; + /** + * Regulatory categories this policy belongs to (e.g., ["children_directed", "age_restricted"]). Used for automatic matching against a campaign plan's declared policy_categories. A single policy can belong to multiple categories. + */ + policy_categories?: string[]; + /** + * Advertising channels this policy applies to. If omitted or null, the policy applies to all channels. + */ + channels?: MediaChannel[]; + /** + * Governance sub-domains this policy applies to. Determines which types of governance agents can declare registry:{policy_id} features. For example, a policy with domains ["creative", "property"] can be declared as a feature by both creative and property governance agents. + */ + governance_domains?: GovernanceDomain[]; + /** + * ISO 8601 date when the regulation or standard takes effect. Before this date, governance agents treat the policy as informational (evaluate but do not block). After this date, the policy is enforced at its declared enforcement level. + */ + effective_date?: string; + /** + * ISO 8601 date when the regulation or standard is no longer enforced. After this date, governance agents stop evaluating this policy. Omit if the policy has no expiration. + */ + sunset_date?: string; + /** + * Link to the source regulation, standard, or legislation. + */ + source_url?: string; + /** + * Name of the issuing body (e.g., "UK Food Standards Agency", "US Federal Trade Commission"). + */ + source_name?: string; + /** + * Natural language policy text describing what is required, prohibited, or recommended. Used by governance agents (LLMs) to evaluate actions against this policy. + */ + policy: string; + /** + * Implementation notes for governance agent developers. Not used in evaluation prompts. + */ + guidance?: string; + /** + * Calibration examples for governance agents, following the Content Standards pattern. + */ + exemplars?: { + /** + * Scenarios that comply with this policy. + */ + pass?: Exemplar[]; + /** + * Scenarios that violate this policy. + */ + fail?: Exemplar[]; + }; + ext?: ExtensionObject; +} +export interface Exemplar { + /** + * A concrete scenario describing an advertising action or configuration. + */ + scenario: string; + /** + * Why this scenario passes or fails the policy. + */ + explanation: string; +} + +// governance/policy-ref.json +/** + * A reference to a policy in the policy registry. Used in brand compliance configurations to declare which registry policies apply. + */ +export interface PolicyReference { + /** + * The unique identifier of the policy in the registry (e.g., "uk_hfss", "us_coppa"). + */ + policy_id: string; + /** + * Pin a specific policy version (semver). If omitted, the current version is used. + */ + version?: string; + /** + * Brand-specific parameter overrides for configurable policies. The accepted shape depends on the policy's config_schema. + */ + config?: {}; +} + + +// media-buy/package-update.json +/** + * Package update configuration for update_media_buy. Identifies package by package_id and specifies fields to modify. Fields not present are left unchanged. Note: product_id, format_ids, and pricing_option_id cannot be changed after creation. + */ +export interface PackageUpdate { + /** + * Seller's ID of package to update + */ + package_id: string; + /** + * Updated budget allocation for this package in the currency specified by the pricing option + */ + budget?: number; + pacing?: Pacing; + /** + * Updated bid price for auction-based pricing options. This is the exact bid/price to honor unless selected pricing_option has max_bid=true, in which case bid_price is the buyer's maximum willingness to pay (ceiling). + */ + bid_price?: number; + /** + * Updated impression goal for this package + */ + impressions?: number; + /** + * Updated flight start date/time for this package in ISO 8601 format. Must fall within the media buy's date range. + */ + start_time?: string; + /** + * Updated flight end date/time for this package in ISO 8601 format. Must fall within the media buy's date range. + */ + end_time?: string; + /** + * Pause/resume specific package (true = paused, false = active) + */ + paused?: boolean; + /** + * Cancel this specific package. Cancellation is irreversible — canceled packages stop delivery and cannot be reactivated. Sellers MAY reject with NOT_CANCELLABLE. + */ + canceled?: true; + /** + * Reason for canceling this package. + */ + cancellation_reason?: string; + /** + * Replace the catalogs this package promotes. Uses replacement semantics — the provided array replaces the current list. Omit to leave catalogs unchanged. + */ + catalogs?: Catalog[]; + /** + * Replace all optimization goals for this package. Uses replacement semantics — omit to leave goals unchanged. + */ + optimization_goals?: OptimizationGoal[]; + targeting_overlay?: TargetingOverlay; + /** + * Keyword targets to add or update on this package. Upserts by (keyword, match_type) identity: if the pair already exists, its bid_price is updated; if not, a new keyword target is added. Use targeting_overlay.keyword_targets in create_media_buy to set the initial list. + */ + keyword_targets_add?: { + /** + * The keyword to target + */ + keyword: string; + /** + * Match type for this keyword + */ + match_type: 'broad' | 'phrase' | 'exact'; + /** + * Per-keyword bid price. Inherits currency and max_bid interpretation from the package's pricing option. + */ + bid_price?: number; + }[]; + /** + * Keyword targets to remove from this package. Removes matching (keyword, match_type) pairs. If a specified pair is not present, sellers SHOULD treat it as a no-op for that entry. + */ + keyword_targets_remove?: { + /** + * The keyword to stop targeting + */ + keyword: string; + /** + * Match type to remove + */ + match_type: 'broad' | 'phrase' | 'exact'; + }[]; + /** + * Negative keywords to add to this package. Appends to the existing negative keyword list — does not replace it. If a keyword+match_type pair already exists, sellers SHOULD treat it as a no-op for that entry. Use targeting_overlay.negative_keywords in create_media_buy to set the initial list. + */ + negative_keywords_add?: { + /** + * The keyword to exclude + */ + keyword: string; + /** + * Match type for exclusion + */ + match_type: 'broad' | 'phrase' | 'exact'; + }[]; + /** + * Negative keywords to remove from this package. Removes matching keyword+match_type pairs from the existing list. If a specified pair is not present, sellers SHOULD treat it as a no-op for that entry. + */ + negative_keywords_remove?: { + /** + * The keyword to stop excluding + */ + keyword: string; + /** + * Match type to remove + */ + match_type: 'broad' | 'phrase' | 'exact'; + }[]; + /** + * Replace creative assignments for this package with optional weights and placement targeting. Uses replacement semantics - omit to leave assignments unchanged. + */ + creative_assignments?: CreativeAssignment[]; + /** + * Upload new creative assets and assign to this package (creatives will be added to library). Use creative_assignments instead for existing library creatives. + */ + creatives?: CreativeAsset[]; + context?: ContextObject; + ext?: ExtensionObject; +} + +// property/base-property-source.json +/** + * A source of properties for a property list. Supports three selection patterns: publisher with tags, publisher with property IDs, or direct identifiers. + */ +export type BasePropertySource = PublisherTagsSource | PublisherPropertyIDsSource | DirectIdentifiersSource; +/** + * Select properties from a publisher by tag membership + */ +export interface PublisherTagsSource { + /** + * Discriminator indicating selection by property tags within a publisher + */ + selection_type: 'publisher_tags'; + /** + * Domain where publisher's adagents.json is hosted (e.g., 'raptive.com') + */ + publisher_domain: string; + /** + * Property tags from the publisher's adagents.json. Selects all properties with these tags. + */ + tags: PropertyTag[]; +} +/** + * Select specific properties from a publisher by ID + */ +export interface PublisherPropertyIDsSource { + /** + * Discriminator indicating selection by specific property IDs within a publisher + */ + selection_type: 'publisher_ids'; + /** + * Domain where publisher's adagents.json is hosted (e.g., 'raptive.com') + */ + publisher_domain: string; + /** + * Specific property IDs from the publisher's adagents.json + */ + property_ids: PropertyID[]; +} +/** + * Select properties by direct identifiers (domains, app IDs, etc.) without publisher context + */ +export interface DirectIdentifiersSource { + /** + * Discriminator indicating selection by direct identifiers + */ + selection_type: 'identifiers'; + /** + * Direct property identifiers (domains, app IDs, etc.) + */ + identifiers: Identifier[]; +} + +// property/feature-requirement.json +/** + * A feature-based requirement for property filtering. Use min_value/max_value for quantitative features, allowed_values for binary/categorical features. + */ +export interface FeatureRequirement { + /** + * Feature to evaluate (discovered via get_adcp_capabilities) + */ + feature_id: string; + /** + * Minimum numeric value required (for quantitative features) + */ + min_value?: number; + /** + * Maximum numeric value allowed (for quantitative features) + */ + max_value?: number; + /** + * Values that pass the requirement (for binary/categorical features) + */ + allowed_values?: unknown[]; + /** + * How to handle properties where this feature is not covered. 'exclude' (default): property is removed from the list. 'include': property passes this requirement (fail-open). + */ + if_not_covered?: 'exclude' | 'include'; +} + + +// property/property-error.json +/** + * Error information for a property that could not be evaluated + */ +export interface PropertyError { + /** + * Error code + */ + code: + | 'PROPERTY_NOT_FOUND' + | 'PROPERTY_NOT_MONITORED' + | 'LIST_NOT_FOUND' + | 'LIST_ACCESS_DENIED' + | 'METHODOLOGY_NOT_SUPPORTED' + | 'JURISDICTION_NOT_SUPPORTED'; + property?: Property; + /** + * Human-readable error message + */ + message: string; +} + +// property/property-feature-definition.json +/** + * Defines a feature that a governance agent can evaluate for properties. Used in get_adcp_capabilities to advertise agent capabilities. + */ +export interface PropertyFeatureDefinition { + /** + * Unique identifier for this feature (e.g., 'consent_quality', 'carbon_score'). Features prefixed with 'registry:' reference standardized policies from the shared policy registry (e.g., 'registry:us_coppa', 'registry:uk_hfss'). Unprefixed feature IDs are agent-defined. + */ + feature_id: string; + /** + * Human-readable name for the feature + */ + name: string; + /** + * Description of what this feature measures or represents + */ + description?: string; + /** + * The type of values this feature produces: binary (true/false), quantitative (numeric range), categorical (enumerated values) + */ + type: 'binary' | 'quantitative' | 'categorical'; + /** + * For quantitative features, the valid range of values + */ + range?: { + /** + * Minimum value + */ + min: number; + /** + * Maximum value + */ + max: number; + }; + /** + * For categorical features, the set of valid values + */ + allowed_values?: string[]; + /** + * What this feature covers (empty arrays = all) + */ + coverage?: { + /** + * Property types this feature applies to + */ + property_types?: string[]; + /** + * Countries where this feature is available + */ + countries?: string[]; + }; + /** + * URL to documentation explaining how this feature is calculated/measured + */ + methodology_url: string; + /** + * Version identifier for the methodology (for audit trails) + */ + methodology_version?: string; + ext?: ExtensionObject; +} + +// property/property-feature.json +/** + * A discrete feature assessment for a property (e.g., from app store privacy labels) + */ +export interface PropertyFeature { + /** + * Identifier for the feature being assessed + */ + feature_id: string; + /** + * The feature value + */ + value: string; + /** + * Source of the feature data (e.g., app_store_privacy_label, tcf_string) + */ + source?: string; +} + + +// property/property-list-changed-webhook.json +/** + * Webhook notification sent when a property list's resolved properties change. Contains a summary only - recipients must call get_property_list to retrieve the updated properties. This keeps payloads small and avoids redundant data transfer. + */ +export interface PropertyListChangedWebhook { + /** + * The event type + */ + event: 'property_list_changed'; + /** + * ID of the property list that changed + */ + list_id: string; + /** + * Name of the property list + */ + list_name?: string; + /** + * Summary of changes to the resolved list + */ + change_summary?: { + /** + * Number of properties added since last resolution + */ + properties_added?: number; + /** + * Number of properties removed since last resolution + */ + properties_removed?: number; + /** + * Total properties in the resolved list + */ + total_properties?: number; + }; + /** + * When the list was re-resolved + */ + resolved_at: string; + /** + * When the consumer should refresh from the governance agent + */ + cache_valid_until?: string; + /** + * Cryptographic signature of the webhook payload, signed with the agent's private key. Recipients MUST verify this signature. + */ + signature: string; + ext?: ExtensionObject; +} + +// property/property-list-filters.json +/** + * Filters that dynamically modify a property list when resolved + */ +export interface PropertyListFilters { + /** + * Property must have feature data for ALL listed countries (ISO codes). When omitted, no country restriction is applied. + */ + countries_all?: string[]; + /** + * Property must support ANY of the listed channels. When omitted, no channel restriction is applied. + */ + channels_any?: MediaChannel[]; + /** + * Filter to these property types + */ + property_types?: PropertyType[]; + /** + * Feature-based requirements. Property must pass ALL requirements (AND logic). + */ + feature_requirements?: FeatureRequirement[]; + /** + * Identifiers to always exclude from results + */ + exclude_identifiers?: Identifier[]; +} + +// property/property-list.json +/** + * A managed property list with optional filters for dynamic evaluation. Lists are resolved at setup time and cached by orchestrators/sellers for real-time use. + */ +export interface PropertyList { + /** + * Unique identifier for this property list + */ + list_id: string; + /** + * Human-readable name for the list + */ + name: string; + /** + * Description of the list's purpose + */ + description?: string; + /** + * Principal identity that owns this list + */ + principal?: string; + /** + * Array of property sources to evaluate. Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers). If omitted, queries the agent's entire property database. + */ + base_properties?: BasePropertySource[]; + filters?: PropertyListFilters; + brand?: BrandReference; + /** + * URL to receive notifications when the resolved list changes + */ + webhook_url?: string; + /** + * Recommended cache duration for resolved list. Consumers should re-fetch after this period. + */ + cache_duration_hours?: number; + /** + * When the list was created + */ + created_at?: string; + /** + * When the list was last modified + */ + updated_at?: string; + /** + * Number of properties in the resolved list (at time of last resolution) + */ + property_count?: number; + /** + * Pricing options for this property list. Present when the requesting account has a billing relationship with the list provider. The buyer passes the selected pricing_option_id in report_usage. + */ + pricing_options?: VendorPricingOption[]; +} + +// sponsored-intelligence/si-capabilities.json +/** + * Capabilities that a brand agent declares or a host supports + */ +export interface SICapabilities { + /** + * Interaction modalities supported + */ + modalities?: { + /** + * Pure text exchange - the baseline modality + */ + conversational?: boolean; + /** + * Audio-based interaction using brand voice + */ + voice?: + | boolean + | { + /** + * TTS provider (elevenlabs, openai, etc.) + */ + provider?: string; + /** + * Brand voice identifier + */ + voice_id?: string; + }; + /** + * Brand video content playback + */ + video?: + | boolean + | { + /** + * Supported video formats (mp4, webm, etc.) + */ + formats?: string[]; + /** + * Maximum video duration + */ + max_duration_seconds?: number; + }; + /** + * Animated video presence with brand avatar + */ + avatar?: + | boolean + | { + /** + * Avatar provider (d-id, heygen, synthesia, etc.) + */ + provider?: string; + /** + * Brand avatar identifier + */ + avatar_id?: string; + }; + }; + /** + * Visual components supported + */ + components?: { + /** + * Standard components that all SI hosts must render + */ + standard?: ('text' | 'link' | 'image' | 'product_card' | 'carousel' | 'action_button')[]; + /** + * Platform-specific extensions (chatgpt_apps_sdk, maps, forms, etc.) + */ + extensions?: {}; + }; + /** + * Commerce capabilities + */ + commerce?: { + /** + * Supports ACP (Agentic Commerce Protocol) checkout handoff + */ + acp_checkout?: boolean; + }; + /** + * A2UI (Agent-to-UI) capabilities + */ + a2ui?: { + /** + * Supports A2UI surface rendering + */ + supported?: boolean; + /** + * Supported A2UI component catalogs (e.g., 'si-standard', 'standard') + */ + catalogs?: string[]; + }; + /** + * Supports MCP Apps for rendering A2UI surfaces in iframes + */ + mcp_apps?: boolean; +} + + +// sponsored-intelligence/si-identity.json +/** + * User identity shared with brand agent (with explicit consent) + */ +export interface SIIdentity { + /** + * Whether user consented to share identity + */ + consent_granted: boolean; + /** + * When consent was granted (ISO 8601) + */ + consent_timestamp?: string; + /** + * What data was consented to share + */ + consent_scope?: ('name' | 'email' | 'shipping_address' | 'phone' | 'locale')[]; + /** + * Brand privacy policy acknowledgment + */ + privacy_policy_acknowledged?: { + /** + * URL to brand's privacy policy + */ + brand_policy_url?: string; + /** + * Version of policy acknowledged + */ + brand_policy_version?: string; + }; + /** + * User data (only present if consent_granted is true) + */ + user?: { + /** + * User's email address + */ + email?: string; + /** + * User's display name + */ + name?: string; + /** + * User's locale (e.g., en-US) + */ + locale?: string; + /** + * User's phone number + */ + phone?: string; + /** + * User's shipping address for accurate pricing + */ + shipping_address?: { + street?: string; + city?: string; + state?: string; + postal_code?: string; + country?: string; + }; + }; + /** + * Session ID for anonymous users (when consent_granted is false) + */ + anonymous_session_id?: string; +} + + +// sponsored-intelligence/si-ui-element.json +/** + * Standard visual component that brand returns and host renders + */ +export type SIUIElement = { + [k: string]: unknown | undefined; +} & { + /** + * Component type + */ + type: + | 'text' + | 'link' + | 'image' + | 'product_card' + | 'carousel' + | 'action_button' + | 'app_handoff' + | 'integration_actions'; + /** + * Component-specific data + */ + data?: {}; +}; + diff --git a/src/lib/types/schemas.generated.ts b/src/lib/types/schemas.generated.ts index 2587f6fb..1c4820c2 100644 --- a/src/lib/types/schemas.generated.ts +++ b/src/lib/types/schemas.generated.ts @@ -1,5 +1,5 @@ // Generated Zod v4 schemas from TypeScript types -// Generated at: 2026-04-15T04:10:46.205Z +// Generated at: 2026-04-15T06:42:23.869Z // Sources: // - core.generated.ts (core types) // - tools.generated.ts (tool types) @@ -1258,500 +1258,499 @@ export const SyncCatalogsErrorSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const AccountReferenceSchema = z.union([z.object({ - account_id: z.string() - }).passthrough(), z.object({ - brand: BrandReferenceSchema, - operator: z.string(), - sandbox: z.boolean().nullish() - }).passthrough()]); +export const A2UIComponentSchema = z.object({ + id: z.string(), + parentId: z.string().nullish(), + component: z.record(z.string(), z.object({}).passthrough()) +}).passthrough(); -export const GeographicTargetingLevelSchema = z.union([z.literal("country"), z.literal("region"), z.literal("metro"), z.literal("postal_area")]); +export const A2UISurfaceSchema = z.object({ + surfaceId: z.string(), + catalogId: z.string().nullish(), + components: z.array(A2UIComponentSchema), + rootId: z.string().nullish(), + dataModel: z.object({}).passthrough().nullish() +}).passthrough(); -export const SignalTargetingSchema = z.union([z.object({ - signal_id: SignalIDSchema, - value_type: z.literal("binary"), - value: z.boolean() - }).passthrough(), z.object({ - signal_id: SignalIDSchema, - value_type: z.literal("categorical"), - values: z.array(z.string()) - }).passthrough(), z.object({ - signal_id: SignalIDSchema, - value_type: z.literal("numeric"), - min_value: z.number().nullish(), - max_value: z.number().nullish() - }).passthrough()]); +export const AuthenticationSchemeSchema = z.union([z.literal("Bearer"), z.literal("HMAC-SHA256")]); -export const PaginationRequestSchema = z.object({ - max_results: z.number().nullish(), - cursor: z.string().nullish() +export const PushNotificationConfigSchema = z.object({ + url: z.string(), + token: z.string().nullish(), + authentication: z.object({ + schemes: z.array(AuthenticationSchemeSchema), + credentials: z.string() + }).passthrough() }).passthrough(); -export const MediaBuyFeaturesSchema = z.record(z.string(), z.boolean()).and(z.object({ - inline_creative_management: z.boolean().nullish(), - property_list_filtering: z.boolean().nullish(), - catalog_management: z.boolean().nullish() -}).passthrough()); +export const AcquireRightsPendingApprovalSchema = z.object({ + rights_id: z.string(), + status: z.literal("pending_approval"), + brand_id: z.string(), + detail: z.string().nullish(), + estimated_response_time: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const CPMPricingOptionSchema = z.object({ - pricing_option_id: z.string(), - pricing_model: z.literal("cpm"), - currency: z.string(), - fixed_price: z.number().nullish(), - floor_price: z.number().nullish(), - max_bid: z.boolean().nullish(), - price_guidance: PriceGuidanceSchema.nullish(), - min_spend_per_package: z.number().nullish(), - price_breakdown: PriceBreakdownSchema.nullish(), - eligible_adjustments: z.array(PriceAdjustmentKindSchema).nullish() +export const AcquireRightsRejectedSchema = z.object({ + rights_id: z.string(), + status: z.literal("rejected"), + brand_id: z.string(), + reason: z.string(), + suggestions: z.array(z.string()).nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const FlatRatePricingOptionSchema = z.object({ +export const AcquireRightsErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const RightsTermsSchema = z.object({ pricing_option_id: z.string(), - pricing_model: z.literal("flat_rate"), + amount: z.number(), currency: z.string(), - fixed_price: z.number().nullish(), - floor_price: z.number().nullish(), - price_guidance: PriceGuidanceSchema.nullish(), - parameters: DoohParametersSchema.nullish(), - min_spend_per_package: z.number().nullish(), - price_breakdown: PriceBreakdownSchema.nullish(), - eligible_adjustments: z.array(PriceAdjustmentKindSchema).nullish() + period: z.union([z.literal("daily"), z.literal("weekly"), z.literal("monthly"), z.literal("quarterly"), z.literal("annual"), z.literal("one_time")]).nullish(), + uses: z.array(RightUseSchema), + impression_cap: z.number().nullish(), + overage_cpm: z.number().nullish(), + start_date: z.string().nullish(), + end_date: z.string().nullish(), + exclusivity: z.object({ + scope: z.string().nullish(), + countries: z.array(z.string()).nullish() + }).passthrough().nullish() }).passthrough(); -export const ProposalSchema = z.object({ - proposal_id: z.string(), - name: z.string(), - description: z.string().nullish(), - allocations: z.array(ProductAllocationSchema), - proposal_status: ProposalStatusSchema.nullish(), +export const GenerationCredentialSchema = z.object({ + provider: z.string(), + rights_key: z.string(), + uses: z.array(RightUseSchema), expires_at: z.string().nullish(), - insertion_order: InsertionOrderSchema.nullish(), - total_budget_guidance: z.object({ - min: z.number().nullish(), - recommended: z.number().nullish(), - max: z.number().nullish(), - currency: z.string().nullish() - }).passthrough().nullish(), - brief_alignment: z.string().nullish(), - forecast: DeliveryForecastSchema.nullish(), + endpoint: z.string().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PricingOptionSchema = z.union([CPMPricingOptionSchema, VCPMPricingOptionSchema, CPCPricingOptionSchema, CPCVPricingOptionSchema, CPVPricingOptionSchema, CPPPricingOptionSchema, CPAPricingOptionSchema, FlatRatePricingOptionSchema, TimeBasedPricingOptionSchema]); - -export const ReportingCapabilitiesSchema = z.object({ - available_reporting_frequencies: z.array(ReportingFrequencySchema), - expected_delay_minutes: z.number(), - timezone: z.string(), - supports_webhooks: z.boolean(), - available_metrics: z.array(AvailableMetricSchema), - supports_creative_breakdown: z.boolean().nullish(), - supports_keyword_breakdown: z.boolean().nullish(), - supports_geo_breakdown: GeographicBreakdownSupportSchema.nullish(), - supports_device_type_breakdown: z.boolean().nullish(), - supports_device_platform_breakdown: z.boolean().nullish(), - supports_audience_breakdown: z.boolean().nullish(), - supports_placement_breakdown: z.boolean().nullish(), - date_range_support: z.union([z.literal("date_range"), z.literal("lifetime_only")]), - measurement_windows: z.array(MeasurementWindowSchema).nullish() -}).passthrough(); - -export const MeasurementReadinessSchema = z.object({ - status: AssessmentStatusSchema, - required_event_types: z.array(EventTypeSchema).nullish(), - missing_event_types: z.array(EventTypeSchema).nullish(), - issues: z.array(DiagnosticIssueSchema).nullish(), - notes: z.string().nullish() +export const GetBrandIdentityRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + brand_id: z.string(), + fields: z.array(z.union([z.literal("description"), z.literal("industries"), z.literal("keller_type"), z.literal("logos"), z.literal("colors"), z.literal("fonts"), z.literal("visual_guidelines"), z.literal("tone"), z.literal("tagline"), z.literal("voice_synthesis"), z.literal("assets"), z.literal("rights")])).nullish(), + use_case: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const InstallmentDeadlinesSchema = z.object({ - booking_deadline: z.string().nullish(), - cancellation_deadline: z.string().nullish(), - material_deadlines: z.array(MaterialDeadlineSchema).nullish() +export const GetBrandIdentityErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); export const AssetContentTypeSchema = z.union([z.literal("image"), z.literal("video"), z.literal("audio"), z.literal("text"), z.literal("markdown"), z.literal("html"), z.literal("css"), z.literal("javascript"), z.literal("vast"), z.literal("daast"), z.literal("url"), z.literal("webhook"), z.literal("brief"), z.literal("catalog")]); -export const WCAGLevelSchema = z.union([z.literal("A"), z.literal("AA"), z.literal("AAA")]); - -export const ListCreativeFormatsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - format_ids: z.array(FormatIDSchema).nullish(), - asset_types: z.array(AssetContentTypeSchema).nullish(), - max_width: z.number().nullish(), - max_height: z.number().nullish(), - min_width: z.number().nullish(), - min_height: z.number().nullish(), - is_responsive: z.boolean().nullish(), - name_search: z.string().nullish(), - wcag_level: WCAGLevelSchema.nullish(), - disclosure_positions: z.array(DisclosurePositionSchema).nullish(), - disclosure_persistence: z.array(DisclosurePersistenceSchema).nullish(), - output_format_ids: z.array(FormatIDSchema).nullish(), - input_format_ids: z.array(FormatIDSchema).nullish(), - pagination: PaginationRequestSchema.nullish(), +export const GetBrandIdentitySuccessSchema = z.object({ + brand_id: z.string(), + house: z.object({ + domain: z.string(), + name: z.string() + }).passthrough(), + names: z.array(z.record(z.string(), z.string())), + description: z.string().nullish(), + industries: z.array(z.string()).nullish(), + keller_type: z.union([z.literal("master"), z.literal("sub_brand"), z.literal("endorsed"), z.literal("independent")]).nullish(), + logos: z.array(z.object({ + url: z.string(), + orientation: z.union([z.literal("square"), z.literal("horizontal"), z.literal("vertical"), z.literal("stacked")]).nullish(), + background: z.union([z.literal("dark-bg"), z.literal("light-bg"), z.literal("transparent-bg")]).nullish(), + variant: z.union([z.literal("primary"), z.literal("secondary"), z.literal("icon"), z.literal("wordmark"), z.literal("full-lockup")]).nullish(), + tags: z.array(z.string()).nullish(), + usage: z.string().nullish(), + width: z.number().nullish(), + height: z.number().nullish() + }).passthrough()).nullish(), + colors: z.object({ + primary: z.union([z.string(), z.array(z.string())]).nullish(), + secondary: z.union([z.string(), z.array(z.string())]).nullish(), + accent: z.union([z.string(), z.array(z.string())]).nullish(), + background: z.union([z.string(), z.array(z.string())]).nullish(), + text: z.union([z.string(), z.array(z.string())]).nullish() + }).passthrough().nullish(), + fonts: z.record(z.string(), z.union([z.string(), z.object({ + family: z.string(), + files: z.array(z.object({ + url: z.string(), + weight: z.number().nullish(), + weight_range: z.array(z.number()).nullish(), + style: z.union([z.literal("normal"), z.literal("italic"), z.literal("oblique")]).nullish() + }).passthrough()).nullish(), + opentype_features: z.array(z.string()).nullish(), + fallbacks: z.array(z.string()).nullish() + }).passthrough()])).and(z.object({ + primary: z.union([z.string(), z.object({ + family: z.string(), + files: z.array(z.object({ + url: z.string(), + weight: z.number().nullish(), + weight_range: z.array(z.number()).nullish(), + style: z.union([z.literal("normal"), z.literal("italic"), z.literal("oblique")]).nullish() + }).passthrough()).nullish(), + opentype_features: z.array(z.string()).nullish(), + fallbacks: z.array(z.string()).nullish() + }).passthrough()]).nullish(), + secondary: z.union([z.string(), z.object({ + family: z.string(), + files: z.array(z.object({ + url: z.string(), + weight: z.number().nullish(), + weight_range: z.array(z.number()).nullish(), + style: z.union([z.literal("normal"), z.literal("italic"), z.literal("oblique")]).nullish() + }).passthrough()).nullish(), + opentype_features: z.array(z.string()).nullish(), + fallbacks: z.array(z.string()).nullish() + }).passthrough()]).nullish() + }).passthrough()).nullish(), + visual_guidelines: z.object({}).passthrough().nullish(), + tone: z.object({ + voice: z.string().nullish(), + attributes: z.array(z.string()).nullish(), + dos: z.array(z.string()).nullish(), + donts: z.array(z.string()).nullish() + }).passthrough().nullish(), + tagline: z.union([z.string(), z.array(z.record(z.string(), z.string()))]).nullish(), + voice_synthesis: z.object({ + provider: z.string().nullish(), + voice_id: z.string().nullish(), + settings: z.object({}).passthrough().nullish() + }).passthrough().nullish(), + assets: z.array(z.object({ + asset_id: z.string(), + asset_type: AssetContentTypeSchema, + url: z.string(), + tags: z.array(z.string()).nullish(), + name: z.string().nullish(), + description: z.string().nullish(), + width: z.number().nullish(), + height: z.number().nullish(), + duration_seconds: z.number().nullish(), + file_size_bytes: z.number().nullish(), + format: z.string().nullish() + }).passthrough()).nullish(), + rights: z.object({ + available_uses: z.array(RightUseSchema).nullish(), + countries: z.array(z.string()).nullish(), + excluded_countries: z.array(z.string()).nullish(), + exclusivity_model: z.string().nullish(), + content_restrictions: z.array(z.string()).nullish() + }).passthrough().nullish(), + available_fields: z.array(z.union([z.literal("description"), z.literal("industries"), z.literal("keller_type"), z.literal("logos"), z.literal("colors"), z.literal("fonts"), z.literal("visual_guidelines"), z.literal("tone"), z.literal("tagline"), z.literal("voice_synthesis"), z.literal("assets"), z.literal("rights")])).nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const FormatIDParameterSchema = z.union([z.literal("dimensions"), z.literal("duration")]); +export const PaginationRequestSchema = z.object({ + max_results: z.number().nullish(), + cursor: z.string().nullish() +}).passthrough(); -export const CpmPricingSchema = z.object({ - model: z.literal("cpm"), - cpm: z.number(), - currency: z.string(), +export const GetRightsErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PercentOfMediaPricingSchema = z.object({ - model: z.literal("percent_of_media"), - percent: z.number(), - max_cpm: z.number().nullish(), +export const PricingModelSchema = z.union([z.literal("cpm"), z.literal("vcpm"), z.literal("cpc"), z.literal("cpcv"), z.literal("cpv"), z.literal("cpp"), z.literal("cpa"), z.literal("flat_rate"), z.literal("time")]); + +export const RightsPricingOptionSchema = z.object({ + pricing_option_id: z.string(), + model: PricingModelSchema, + price: z.number(), currency: z.string(), + uses: z.array(RightUseSchema), + period: z.union([z.literal("daily"), z.literal("weekly"), z.literal("monthly"), z.literal("quarterly"), z.literal("annual"), z.literal("one_time")]).nullish(), + impression_cap: z.number().nullish(), + overage_cpm: z.number().nullish(), + description: z.string().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const FlatFeePricingSchema = z.object({ - model: z.literal("flat_fee"), - amount: z.number(), - period: z.union([z.literal("monthly"), z.literal("quarterly"), z.literal("annual"), z.literal("campaign")]), - currency: z.string(), - ext: ExtensionObjectSchema.nullish() +export const PublisherCollectionsSourceSchema = z.object({ + selection_type: z.literal("publisher_collections"), + publisher_domain: z.string(), + collection_ids: z.array(z.string()) }).passthrough(); -export const PerUnitPricingSchema = z.object({ - model: z.literal("per_unit"), - unit: z.string(), - unit_price: z.number(), - currency: z.string(), - ext: ExtensionObjectSchema.nullish() +export const DistributionIdentifierTypeSchema = z.union([z.literal("apple_podcast_id"), z.literal("spotify_collection_id"), z.literal("rss_url"), z.literal("podcast_guid"), z.literal("amazon_music_id"), z.literal("iheart_id"), z.literal("podcast_index_id"), z.literal("youtube_channel_id"), z.literal("youtube_playlist_id"), z.literal("amazon_title_id"), z.literal("roku_channel_id"), z.literal("pluto_channel_id"), z.literal("tubi_id"), z.literal("peacock_id"), z.literal("tiktok_id"), z.literal("twitch_channel"), z.literal("imdb_id"), z.literal("gracenote_id"), z.literal("eidr_id"), z.literal("domain"), z.literal("substack_id")]); + +export const GenreTaxonomySchema = z.union([z.literal("iab_content_3.0"), z.literal("iab_content_2.2"), z.literal("gracenote"), z.literal("eidr"), z.literal("apple_genres"), z.literal("google_genres"), z.literal("roku"), z.literal("amazon_genres"), z.literal("custom")]); + +export const DistributionIDsSourceSchema = z.object({ + selection_type: z.literal("distribution_ids"), + identifiers: z.array(z.object({ + type: DistributionIdentifierTypeSchema, + value: z.string() + }).passthrough()) }).passthrough(); -export const CreativeAgentCapabilitySchema = z.union([z.literal("validation"), z.literal("assembly"), z.literal("generation"), z.literal("preview"), z.literal("delivery")]); +export const PublisherGenresSourceSchema = z.object({ + selection_type: z.literal("publisher_genres"), + publisher_domain: z.string(), + genres: z.array(z.string()), + genre_taxonomy: GenreTaxonomySchema +}).passthrough(); -export const OverlaySchema = z.object({ - id: z.string(), - description: z.string().nullish(), - visual: z.object({ - url: z.string().nullish(), - light: z.string().nullish(), - dark: z.string().nullish() +export const CollectionListChangedWebhookSchema = z.object({ + event: z.literal("collection_list_changed"), + list_id: z.string(), + list_name: z.string().nullish(), + change_summary: z.object({ + collections_added: z.number().nullish(), + collections_removed: z.number().nullish(), + total_collections: z.number().nullish() }).passthrough().nullish(), - bounds: z.object({ - x: z.number(), - y: z.number(), - width: z.number(), - height: z.number(), - unit: z.union([z.literal("px"), z.literal("fraction"), z.literal("inches"), z.literal("cm"), z.literal("mm"), z.literal("pt")]) - }).passthrough() + resolved_at: z.string(), + cache_valid_until: z.string().nullish(), + signature: z.string(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const BaseGroupAssetSchema = z.object({ - asset_id: z.string(), - asset_role: z.string().nullish(), - required: z.boolean(), - overlays: z.array(OverlaySchema).nullish() -}).passthrough(); +export const ProductionQualitySchema = z.union([z.literal("professional"), z.literal("prosumer"), z.literal("ugc")]); -export const CreativeBriefSchema = z.object({ - name: z.string(), - objective: z.union([z.literal("awareness"), z.literal("consideration"), z.literal("conversion"), z.literal("retention"), z.literal("engagement")]).nullish(), - tone: z.string().nullish(), - audience: z.string().nullish(), - territory: z.string().nullish(), - messaging: z.object({ - headline: z.string().nullish(), - tagline: z.string().nullish(), - cta: z.string().nullish(), - key_messages: z.array(z.string()).nullish() - }).passthrough().nullish(), - reference_assets: z.array(ReferenceAssetSchema).nullish(), - compliance: z.object({ - required_disclosures: z.array(z.object({ - text: z.string(), - position: DisclosurePositionSchema.nullish(), - jurisdictions: z.array(z.string()).nullish(), - regulation: z.string().nullish(), - min_duration_ms: z.number().nullish(), - language: z.string().nullish(), - persistence: DisclosurePersistenceSchema.nullish() - }).passthrough()).nullish(), - prohibited_claims: z.array(z.string()).nullish() - }).passthrough().nullish() +export const CollectionListFiltersSchema = z.object({ + content_ratings_exclude: z.array(ContentRatingSchema).nullish(), + content_ratings_include: z.array(ContentRatingSchema).nullish(), + genres_exclude: z.array(z.string()).nullish(), + genres_include: z.array(z.string()).nullish(), + genre_taxonomy: GenreTaxonomySchema.nullish(), + kinds: z.array(z.union([z.literal("series"), z.literal("publication"), z.literal("event_series"), z.literal("rotation")])).nullish(), + exclude_distribution_ids: z.array(z.object({ + type: DistributionIdentifierTypeSchema, + value: z.string() + }).passthrough()).nullish(), + production_quality: z.array(ProductionQualitySchema).nullish() }).passthrough(); -export const AdvertiserIndustrySchema = z.union([z.literal("automotive"), z.literal("automotive.electric_vehicles"), z.literal("automotive.parts_accessories"), z.literal("automotive.luxury"), z.literal("beauty_cosmetics"), z.literal("beauty_cosmetics.skincare"), z.literal("beauty_cosmetics.fragrance"), z.literal("beauty_cosmetics.haircare"), z.literal("cannabis"), z.literal("cpg"), z.literal("cpg.personal_care"), z.literal("cpg.household"), z.literal("dating"), z.literal("education"), z.literal("education.higher_education"), z.literal("education.online_learning"), z.literal("education.k12"), z.literal("energy_utilities"), z.literal("energy_utilities.renewable"), z.literal("fashion_apparel"), z.literal("fashion_apparel.luxury"), z.literal("fashion_apparel.sportswear"), z.literal("finance"), z.literal("finance.banking"), z.literal("finance.insurance"), z.literal("finance.investment"), z.literal("finance.cryptocurrency"), z.literal("food_beverage"), z.literal("food_beverage.alcohol"), z.literal("food_beverage.restaurants"), z.literal("food_beverage.packaged_goods"), z.literal("gambling_betting"), z.literal("gambling_betting.sports_betting"), z.literal("gambling_betting.casino"), z.literal("gaming"), z.literal("gaming.mobile"), z.literal("gaming.console_pc"), z.literal("gaming.esports"), z.literal("government_nonprofit"), z.literal("government_nonprofit.political"), z.literal("government_nonprofit.charity"), z.literal("healthcare"), z.literal("healthcare.pharmaceutical"), z.literal("healthcare.medical_devices"), z.literal("healthcare.wellness"), z.literal("home_garden"), z.literal("home_garden.furniture"), z.literal("home_garden.home_improvement"), z.literal("media_entertainment"), z.literal("media_entertainment.podcasts"), z.literal("media_entertainment.music"), z.literal("media_entertainment.film_tv"), z.literal("media_entertainment.publishing"), z.literal("media_entertainment.live_events"), z.literal("pets"), z.literal("professional_services"), z.literal("professional_services.legal"), z.literal("professional_services.consulting"), z.literal("real_estate"), z.literal("real_estate.residential"), z.literal("real_estate.commercial"), z.literal("recruitment_hr"), z.literal("retail"), z.literal("retail.ecommerce"), z.literal("retail.department_stores"), z.literal("sports_fitness"), z.literal("sports_fitness.equipment"), z.literal("sports_fitness.teams_leagues"), z.literal("technology"), z.literal("technology.software"), z.literal("technology.hardware"), z.literal("technology.ai_ml"), z.literal("telecom"), z.literal("telecom.mobile_carriers"), z.literal("telecom.internet_providers"), z.literal("transportation_logistics"), z.literal("travel_hospitality"), z.literal("travel_hospitality.airlines"), z.literal("travel_hospitality.hotels"), z.literal("travel_hospitality.cruise"), z.literal("travel_hospitality.tourism")]); - -export const StartTimingSchema = z.union([z.literal("asap"), z.string()]); +export const BaseCollectionSourceSchema = z.union([DistributionIDsSourceSchema, PublisherCollectionsSourceSchema, PublisherGenresSourceSchema]); -export const AuthenticationSchemeSchema = z.union([z.literal("Bearer"), z.literal("HMAC-SHA256")]); +export const AssetAccessSchema = z.union([z.object({ + method: z.literal("bearer_token"), + token: z.string() + }).passthrough(), z.object({ + method: z.literal("service_account"), + provider: z.union([z.literal("gcp"), z.literal("aws")]), + credentials: z.object({}).passthrough().nullish() + }).passthrough(), z.object({ + method: z.literal("signed_url") + }).passthrough()]); -export const PushNotificationConfigSchema = z.object({ - url: z.string(), - token: z.string().nullish(), - authentication: z.object({ - schemes: z.array(AuthenticationSchemeSchema), - credentials: z.string() - }).passthrough() +export const ArtifactSchema = z.object({ + property_rid: z.string(), + artifact_id: z.string(), + variant_id: z.string().nullish(), + format_id: FormatIDSchema.nullish(), + url: z.string().nullish(), + published_time: z.string().nullish(), + last_update_time: z.string().nullish(), + assets: z.array(z.union([z.object({ + type: z.literal("text"), + role: z.union([z.literal("title"), z.literal("paragraph"), z.literal("heading"), z.literal("caption"), z.literal("quote"), z.literal("list_item"), z.literal("description")]).nullish(), + content: z.string(), + content_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("text/html"), z.literal("application/json")]).nullish(), + language: z.string().nullish(), + heading_level: z.number().nullish(), + provenance: ProvenanceSchema.nullish() + }).passthrough(), z.object({ + type: z.literal("image"), + url: z.string(), + access: AssetAccessSchema.nullish(), + alt_text: z.string().nullish(), + caption: z.string().nullish(), + width: z.number().nullish(), + height: z.number().nullish(), + provenance: ProvenanceSchema.nullish() + }).passthrough(), z.object({ + type: z.literal("video"), + url: z.string(), + access: AssetAccessSchema.nullish(), + duration_ms: z.number().nullish(), + transcript: z.string().nullish(), + transcript_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("application/json")]).nullish(), + transcript_source: z.union([z.literal("original_script"), z.literal("subtitles"), z.literal("closed_captions"), z.literal("dub"), z.literal("generated")]).nullish(), + thumbnail_url: z.string().nullish(), + provenance: ProvenanceSchema.nullish() + }).passthrough(), z.object({ + type: z.literal("audio"), + url: z.string(), + access: AssetAccessSchema.nullish(), + duration_ms: z.number().nullish(), + transcript: z.string().nullish(), + transcript_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("application/json")]).nullish(), + transcript_source: z.union([z.literal("original_script"), z.literal("closed_captions"), z.literal("generated")]).nullish(), + provenance: ProvenanceSchema.nullish() + }).passthrough()])), + metadata: z.object({ + canonical: z.string().nullish(), + author: z.string().nullish(), + keywords: z.string().nullish(), + open_graph: z.object({}).passthrough().nullish(), + twitter_card: z.object({}).passthrough().nullish(), + json_ld: z.array(z.object({}).passthrough()).nullish() + }).passthrough().nullish(), + provenance: ProvenanceSchema.nullish(), + identifiers: z.object({ + apple_podcast_id: z.string().nullish(), + spotify_collection_id: z.string().nullish(), + podcast_guid: z.string().nullish(), + youtube_video_id: z.string().nullish(), + rss_url: z.string().nullish() + }).passthrough().nullish() }).passthrough(); -export const ReportingWebhookSchema = z.object({ - url: z.string(), - token: z.string().nullish(), - authentication: z.object({ - schemes: z.array(AuthenticationSchemeSchema), - credentials: z.string() - }).passthrough(), - reporting_frequency: z.union([z.literal("hourly"), z.literal("daily"), z.literal("monthly")]), - requested_metrics: z.array(AvailableMetricSchema).nullish() +export const CpmPricingSchema = z.object({ + model: z.literal("cpm"), + cpm: z.number(), + currency: z.string(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const TargetingOverlaySchema = z.object({ - geo_countries: z.array(z.string()).nullish(), - geo_countries_exclude: z.array(z.string()).nullish(), - geo_regions: z.array(z.string()).nullish(), - geo_regions_exclude: z.array(z.string()).nullish(), - geo_metros: z.array(z.object({ - system: MetroAreaSystemSchema, - values: z.array(z.string()) - }).passthrough()).nullish(), - geo_metros_exclude: z.array(z.object({ - system: MetroAreaSystemSchema, - values: z.array(z.string()) - }).passthrough()).nullish(), - geo_postal_areas: z.array(z.object({ - system: PostalCodeSystemSchema, - values: z.array(z.string()) - }).passthrough()).nullish(), - geo_postal_areas_exclude: z.array(z.object({ - system: PostalCodeSystemSchema, - values: z.array(z.string()) - }).passthrough()).nullish(), - daypart_targets: z.array(DaypartTargetSchema).nullish(), - axe_include_segment: z.string().nullish(), - axe_exclude_segment: z.string().nullish(), - audience_include: z.array(z.string()).nullish(), - audience_exclude: z.array(z.string()).nullish(), - frequency_cap: FrequencyCapSchema.nullish(), - property_list: PropertyListReferenceSchema.nullish(), - collection_list: CollectionListReferenceSchema.nullish(), - collection_list_exclude: CollectionListReferenceSchema.nullish(), - age_restriction: z.object({ - min: z.number(), - verification_required: z.boolean().nullish(), - accepted_methods: z.array(AgeVerificationMethodSchema).nullish() - }).passthrough().nullish(), - device_platform: z.array(DevicePlatformSchema).nullish(), - device_type: z.array(DeviceTypeSchema).nullish(), - device_type_exclude: z.array(DeviceTypeSchema).nullish(), - store_catchments: z.array(z.object({ - catalog_id: z.string(), - store_ids: z.array(z.string()).nullish(), - catchment_ids: z.array(z.string()).nullish() - }).passthrough()).nullish(), - geo_proximity: z.array(z.record(z.string(), z.unknown())).nullish(), - language: z.array(z.string()).nullish(), - keyword_targets: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]), - bid_price: z.number().nullish() - }).passthrough()).nullish(), - negative_keywords: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) - }).passthrough()).nullish() +export const PercentOfMediaPricingSchema = z.object({ + model: z.literal("percent_of_media"), + percent: z.number(), + max_cpm: z.number().nullish(), + currency: z.string(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const BriefAssetSchema = CreativeBriefSchema; - -export const PackageSchema = z.object({ - package_id: z.string(), - product_id: z.string().nullish(), - budget: z.number().nullish(), - pacing: PacingSchema.nullish(), - pricing_option_id: z.string().nullish(), - bid_price: z.number().nullish(), - price_breakdown: PriceBreakdownSchema.nullish(), - impressions: z.number().nullish(), - catalogs: z.array(CatalogSchema).nullish(), - format_ids: z.array(FormatIDSchema).nullish(), - targeting_overlay: TargetingOverlaySchema.nullish(), - measurement_terms: MeasurementTermsSchema.nullish(), - performance_standards: z.array(PerformanceStandardSchema).nullish(), - creative_assignments: z.array(CreativeAssignmentSchema).nullish(), - format_ids_to_provide: z.array(FormatIDSchema).nullish(), - optimization_goals: z.array(OptimizationGoalSchema).nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - paused: z.boolean().nullish(), - canceled: z.boolean().nullish(), - cancellation: z.object({ - canceled_at: z.string(), - canceled_by: CanceledBySchema, - reason: z.string().nullish(), - acknowledged_at: z.string().nullish() - }).passthrough().nullish(), - agency_estimate_number: z.string().nullish(), - creative_deadline: z.string().nullish(), - context: ContextObjectSchema.nullish(), +export const FlatFeePricingSchema = z.object({ + model: z.literal("flat_fee"), + amount: z.number(), + period: z.union([z.literal("monthly"), z.literal("quarterly"), z.literal("annual"), z.literal("campaign")]), + currency: z.string(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PlannedDeliverySchema = z.object({ - geo: z.object({ - countries: z.array(z.string()).nullish(), - regions: z.array(z.string()).nullish() - }).passthrough().nullish(), - channels: z.array(MediaChannelSchema).nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - frequency_cap: FrequencyCapSchema.nullish(), - audience_summary: z.string().nullish(), - audience_targeting: z.array(AudienceSelectorSchema).nullish(), - total_budget: z.number().nullish(), - currency: z.string().nullish(), - enforced_policies: z.array(z.string()).nullish(), +export const PerUnitPricingSchema = z.object({ + model: z.literal("per_unit"), + unit: z.string(), + unit_price: z.number(), + currency: z.string(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreativeAssetSchema = z.object({ - creative_id: z.string(), - name: z.string(), - format_id: FormatIDSchema, - assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])), - inputs: z.array(z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough()).nullish(), - tags: z.array(z.string()).nullish(), - status: CreativeStatusSchema.nullish(), - weight: z.number().nullish(), - placement_ids: z.array(z.string()).nullish(), - industry_identifiers: z.array(IndustryIdentifierSchema).nullish(), - provenance: ProvenanceSchema.nullish() -}).passthrough(); +export const AccountReferenceSchema = z.union([z.object({ + account_id: z.string() + }).passthrough(), z.object({ + brand: BrandReferenceSchema, + operator: z.string(), + sandbox: z.boolean().nullish() + }).passthrough()]); -export const UpdateMediaBuySuccessSchema = z.object({ - media_buy_id: z.string(), - status: MediaBuyStatusSchema.nullish(), - revision: z.number().nullish(), - implementation_date: z.string().nullish().nullable(), - invoice_recipient: BusinessEntitySchema.nullish(), - affected_packages: z.array(PackageSchema).nullish(), - valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const ActivationKeySchema = z.union([z.object({ + type: z.literal("segment_id"), + segment_id: z.string() + }).passthrough(), z.object({ + type: z.literal("key_value"), + key: z.string(), + value: z.string() + }).passthrough()]); + +export const AgentSigningKeySchema = z.object({ + kid: z.string(), + kty: z.string(), + alg: z.string().nullish(), + use: z.string().nullish(), + crv: z.string().nullish(), + x: z.string().nullish(), + y: z.string().nullish(), + n: z.string().nullish(), + e: z.string().nullish() }).passthrough(); -export const GetMediaBuysRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema.nullish(), - media_buy_ids: z.array(z.string()).nullish(), - status_filter: z.union([MediaBuyStatusSchema, z.array(MediaBuyStatusSchema)]).nullish(), - include_snapshot: z.boolean().nullish(), - include_history: z.number().nullish(), - pagination: PaginationRequestSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const AttributionModelSchema = z.union([z.literal("last_touch"), z.literal("first_touch"), z.literal("linear"), z.literal("time_decay"), z.literal("data_driven")]); + +export const AttributionWindowSchema = z.object({ + post_click: DurationSchema.nullish(), + post_view: DurationSchema.nullish(), + model: AttributionModelSchema }).passthrough(); -export const CreativeApprovalStatusSchema = z.union([z.literal("pending_review"), z.literal("approved"), z.literal("rejected")]); +export const UIDTypeSchema = z.union([z.literal("rampid"), z.literal("id5"), z.literal("uid2"), z.literal("euid"), z.literal("pairid"), z.literal("maid"), z.literal("hashed_email"), z.literal("publisher_first_party"), z.literal("other")]); -export const PackageStatusSchema = z.object({ - package_id: z.string(), - product_id: z.string().nullish(), - budget: z.number().nullish(), - currency: z.string().nullish(), - bid_price: z.number().nullish(), - impressions: z.number().nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - paused: z.boolean().nullish(), - canceled: z.boolean().nullish(), - cancellation: z.object({ - canceled_at: z.string(), - canceled_by: CanceledBySchema, - reason: z.string().nullish() - }).passthrough().nullish(), - creative_deadline: z.string().nullish(), - creative_approvals: z.array(z.object({ - creative_id: z.string(), - approval_status: CreativeApprovalStatusSchema.nullish(), - rejection_reason: z.string().nullish() - }).passthrough()).nullish(), - format_ids_pending: z.array(FormatIDSchema).nullish(), - snapshot_unavailable_reason: z.union([z.literal("SNAPSHOT_UNSUPPORTED"), z.literal("SNAPSHOT_TEMPORARILY_UNAVAILABLE"), z.literal("SNAPSHOT_PERMISSION_DENIED")]).nullish(), - snapshot: z.object({ - as_of: z.string(), - staleness_seconds: z.number(), - impressions: z.number(), - spend: z.number(), - currency: z.string().nullish(), - clicks: z.number().nullish(), - pacing_index: z.number().nullish(), - delivery_status: z.union([z.literal("delivering"), z.literal("not_delivering"), z.literal("completed"), z.literal("budget_exhausted"), z.literal("flight_ended"), z.literal("goal_met")]).nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough().nullish(), - ext: ExtensionObjectSchema.nullish() +export const TransportModeSchema = z.union([z.literal("walking"), z.literal("cycling"), z.literal("driving"), z.literal("public_transport")]); + +export const DistanceUnitSchema = z.union([z.literal("km"), z.literal("mi"), z.literal("m")]); + +export const CollectionDistributionSchema = z.object({ + publisher_domain: z.string(), + identifiers: z.array(z.object({ + type: DistributionIdentifierTypeSchema, + value: z.string() + }).passthrough()) }).passthrough(); -export const AttributionModelSchema = z.union([z.literal("last_touch"), z.literal("first_touch"), z.literal("linear"), z.literal("time_decay"), z.literal("data_driven")]); +export const CollectionCadenceSchema = z.union([z.literal("daily"), z.literal("weekly"), z.literal("monthly"), z.literal("seasonal"), z.literal("event"), z.literal("irregular")]); -export const SortMetricSchema = z.union([z.literal("impressions"), z.literal("spend"), z.literal("clicks"), z.literal("ctr"), z.literal("views"), z.literal("completed_views"), z.literal("completion_rate"), z.literal("conversions"), z.literal("conversion_value"), z.literal("roas"), z.literal("cost_per_acquisition"), z.literal("new_to_brand_rate"), z.literal("leads"), z.literal("grps"), z.literal("reach"), z.literal("frequency"), z.literal("engagements"), z.literal("follows"), z.literal("saves"), z.literal("profile_visits"), z.literal("engagement_rate"), z.literal("cost_per_click")]); +export const CollectionStatusSchema = z.union([z.literal("active"), z.literal("hiatus"), z.literal("ended"), z.literal("upcoming")]); -export const GetMediaBuyDeliveryRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema.nullish(), - media_buy_ids: z.array(z.string()).nullish(), - status_filter: z.union([MediaBuyStatusSchema, z.array(MediaBuyStatusSchema)]).nullish(), - start_date: z.string().nullish(), - end_date: z.string().nullish(), - include_package_daily_breakdown: z.boolean().nullish(), - attribution_window: z.object({ - post_click: DurationSchema.nullish(), - post_view: DurationSchema.nullish(), - model: AttributionModelSchema.nullish() - }).passthrough().nullish(), - reporting_dimensions: z.object({ - geo: z.object({ - geo_level: GeographicTargetingLevelSchema, - system: z.union([MetroAreaSystemSchema, PostalCodeSystemSchema]).nullish(), - limit: z.number().nullish(), - sort_by: SortMetricSchema.nullish() - }).passthrough().nullish(), - device_type: z.object({ - limit: z.number().nullish(), - sort_by: SortMetricSchema.nullish() - }).passthrough().nullish(), - device_platform: z.object({ - limit: z.number().nullish(), - sort_by: SortMetricSchema.nullish() - }).passthrough().nullish(), - audience: z.object({ - limit: z.number().nullish(), - sort_by: SortMetricSchema.nullish() - }).passthrough().nullish(), - placement: z.object({ - limit: z.number().nullish(), - sort_by: SortMetricSchema.nullish() - }).passthrough().nullish() - }).passthrough().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const CollectionRelationshipSchema = z.union([z.literal("spinoff"), z.literal("companion"), z.literal("sequel"), z.literal("prequel"), z.literal("crossover")]); + +export const LimitedSeriesSchema = z.object({ + total_installments: z.number(), + starts: z.string().nullish(), + ends: z.string().nullish() }).passthrough(); -export const PricingModelSchema = z.union([z.literal("cpm"), z.literal("vcpm"), z.literal("cpc"), z.literal("cpcv"), z.literal("cpv"), z.literal("cpp"), z.literal("cpa"), z.literal("flat_rate"), z.literal("time")]); +export const DeadlinePolicySchema = z.object({ + booking_lead_days: z.number().nullish(), + cancellation_lead_days: z.number().nullish(), + material_stages: z.array(z.object({ + stage: z.string(), + lead_days: z.number(), + label: z.string().nullish() + }).passthrough()).nullish(), + business_days_only: z.boolean().nullish() +}).passthrough(); -export const AudienceSourceSchema = z.union([z.literal("synced"), z.literal("platform"), z.literal("third_party"), z.literal("lookalike"), z.literal("retargeting"), z.literal("unknown")]); +export const CreativeFiltersSchema = z.object({ + accounts: z.array(AccountReferenceSchema).nullish(), + statuses: z.array(CreativeStatusSchema).nullish(), + tags: z.array(z.string()).nullish(), + tags_any: z.array(z.string()).nullish(), + name_contains: z.string().nullish(), + creative_ids: z.array(z.string()).nullish(), + created_after: z.string().nullish(), + created_before: z.string().nullish(), + updated_after: z.string().nullish(), + updated_before: z.string().nullish(), + assigned_to_packages: z.array(z.string()).nullish(), + media_buy_ids: z.array(z.string()).nullish(), + unassigned: z.boolean().nullish(), + has_served: z.boolean().nullish(), + concept_ids: z.array(z.string()).nullish(), + format_ids: z.array(FormatIDSchema).nullish(), + has_variables: z.boolean().nullish() +}).passthrough(); -export const AttributionWindowSchema = z.object({ - post_click: DurationSchema.nullish(), - post_view: DurationSchema.nullish(), - model: AttributionModelSchema +export const CreativeItemSchema = z.union([z.object({ + asset_kind: z.literal("media"), + asset_type: z.string(), + asset_id: z.string(), + content_uri: z.string() + }).passthrough(), z.object({ + asset_kind: z.literal("text"), + asset_type: z.string(), + asset_id: z.string(), + content: z.union([z.string(), z.array(z.string())]) + }).passthrough()]); + +export const CreativeVariableSchema = z.object({ + variable_id: z.string(), + name: z.string(), + variable_type: z.union([z.literal("text"), z.literal("image"), z.literal("video"), z.literal("audio"), z.literal("url"), z.literal("number"), z.literal("boolean"), z.literal("color"), z.literal("date")]), + default_value: z.string().nullish(), + required: z.boolean().nullish() }).passthrough(); export const DeliveryMetricsSchema = z.object({ @@ -1819,45 +1818,99 @@ export const DeliveryMetricsSchema = z.object({ }).passthrough()).nullish() }).passthrough(); -export const MetricTypeSchema = z.union([z.literal("overall_performance"), z.literal("conversion_rate"), z.literal("brand_lift"), z.literal("click_through_rate"), z.literal("completion_rate"), z.literal("viewability"), z.literal("brand_safety"), z.literal("cost_efficiency")]); +export const IdentifierSchema = z.object({ + type: PropertyIdentifierTypesSchema, + value: z.string() +}).passthrough(); -export const FeedbackSourceSchema = z.union([z.literal("buyer_attribution"), z.literal("third_party_measurement"), z.literal("platform_analytics"), z.literal("verification_partner")]); +export const DateRangeSchema = z.object({ + start: z.string(), + end: z.string() +}).passthrough(); export const DatetimeRangeSchema = z.object({ start: z.string(), end: z.string() }).passthrough(); -export const ProvidePerformanceFeedbackSuccessSchema = z.object({ - success: z.literal(true), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const DeploymentSchema = z.union([z.object({ + type: z.literal("platform"), + platform: z.string(), + account: z.string().nullish(), + is_live: z.boolean(), + activation_key: ActivationKeySchema.nullish(), + estimated_activation_duration_minutes: z.number().nullish(), + deployed_at: z.string().nullish() + }).passthrough(), z.object({ + type: z.literal("agent"), + agent_url: z.string(), + account: z.string().nullish(), + is_live: z.boolean(), + activation_key: ActivationKeySchema.nullish(), + estimated_activation_duration_minutes: z.number().nullish(), + deployed_at: z.string().nullish() + }).passthrough()]); + +export const PriceSchema = z.object({ + amount: z.number(), + currency: z.string(), + period: z.union([z.literal("night"), z.literal("month"), z.literal("year"), z.literal("one_time")]).nullish() }).passthrough(); -export const ProvidePerformanceFeedbackErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), +export const OfferingAssetGroupSchema = z.object({ + asset_group_id: z.string(), + asset_type: AssetContentTypeSchema, + items: z.array(z.union([TextAssetSchema, ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, URLAssetSchema, HTMLAssetSchema, MarkdownAssetSchema, VASTAssetSchema, DAASTAssetSchema, CSSAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema])), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SyncEventSourcesRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema, - event_sources: z.array(z.object({ - event_source_id: z.string(), - name: z.string().nullish(), - event_types: z.array(EventTypeSchema).nullish(), - allowed_domains: z.array(z.string()).nullish() - }).passthrough()).nullish(), - delete_missing: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), +export const DestinationSchema = z.union([z.object({ + type: z.literal("platform"), + platform: z.string(), + account: z.string().nullish() + }).passthrough(), z.object({ + type: z.literal("agent"), + agent_url: z.string(), + account: z.string().nullish() + }).passthrough()]); + +export const EducationItemSchema = z.object({ + program_id: z.string(), + name: z.string(), + school: z.string(), + description: z.string().nullish(), + subject: z.string().nullish(), + degree_type: z.union([z.literal("certificate"), z.literal("associate"), z.literal("bachelor"), z.literal("master"), z.literal("doctorate"), z.literal("professional"), z.literal("bootcamp")]).nullish(), + level: z.union([z.literal("beginner"), z.literal("intermediate"), z.literal("advanced")]).nullish(), + price: PriceSchema.nullish(), + duration: z.string().nullish(), + start_date: z.string().nullish(), + language: z.string().nullish(), + modality: z.union([z.literal("online"), z.literal("in_person"), z.literal("hybrid")]).nullish(), + location: z.string().nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SyncEventSourcesErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), +export const EventCustomDataSchema = z.object({ + value: z.number().nullish(), + currency: z.string().nullish(), + order_id: z.string().nullish(), + content_ids: z.array(z.string()).nullish(), + content_type: z.string().nullish(), + content_name: z.string().nullish(), + content_category: z.string().nullish(), + num_items: z.number().nullish(), + search_string: z.string().nullish(), + contents: z.array(z.object({ + id: z.string(), + quantity: z.number().nullish(), + price: z.number().nullish(), + brand: z.string().nullish() + }).passthrough()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); @@ -1875,8 +1928,6 @@ export const EventSourceHealthSchema = z.object({ issues: z.array(DiagnosticIssueSchema).nullish() }).passthrough(); -export const UIDTypeSchema = z.union([z.literal("rampid"), z.literal("id5"), z.literal("uid2"), z.literal("euid"), z.literal("pairid"), z.literal("maid"), z.literal("hashed_email"), z.literal("publisher_first_party"), z.literal("other")]); - export const UserMatchSchema = z.object({ uids: z.array(z.object({ type: UIDTypeSchema, @@ -1891,387 +1942,473 @@ export const UserMatchSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const EventCustomDataSchema = z.object({ - value: z.number().nullish(), - currency: z.string().nullish(), - order_id: z.string().nullish(), - content_ids: z.array(z.string()).nullish(), - content_type: z.string().nullish(), - content_name: z.string().nullish(), - content_category: z.string().nullish(), - num_items: z.number().nullish(), - search_string: z.string().nullish(), - contents: z.array(z.object({ - id: z.string(), - quantity: z.number().nullish(), - price: z.number().nullish(), - brand: z.string().nullish() - }).passthrough()).nullish(), +export const EventSchema = z.object({ + event_id: z.string(), + event_type: EventTypeSchema, + event_time: z.string(), + user_match: UserMatchSchema.nullish(), + custom_data: EventCustomDataSchema.nullish(), + action_source: ActionSourceSchema.nullish(), + event_source_url: z.string().nullish(), + custom_event_name: z.string().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const LogEventSuccessSchema = z.object({ - events_received: z.number(), - events_processed: z.number(), - partial_failures: z.array(z.object({ - event_id: z.string(), - code: z.string(), - message: z.string() - }).passthrough()).nullish(), - warnings: z.array(z.string()).nullish(), - match_quality: z.number().nullish(), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), +export const FlightItemSchema = z.object({ + flight_id: z.string(), + origin: z.object({ + airport_code: z.string(), + city: z.string().nullish() + }).passthrough(), + destination: z.object({ + airport_code: z.string(), + city: z.string().nullish() + }).passthrough(), + airline: z.string().nullish(), + price: PriceSchema.nullish(), + description: z.string().nullish(), + departure_time: z.string().nullish(), + arrival_time: z.string().nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const LogEventErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); +export const FormatIDParameterSchema = z.union([z.literal("dimensions"), z.literal("duration")]); -export const AudienceMemberSchema = z.object({ - external_id: z.string(), - hashed_email: z.string().nullish(), - hashed_phone: z.string().nullish(), - uids: z.array(z.object({ - type: UIDTypeSchema, - value: z.string() - }).passthrough()).nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); +export const WCAGLevelSchema = z.union([z.literal("A"), z.literal("AA"), z.literal("AAA")]); -export const ConsentBasisSchema = z.union([z.literal("consent"), z.literal("legitimate_interest"), z.literal("contract"), z.literal("legal_obligation")]); +export const OverlaySchema = z.object({ + id: z.string(), + description: z.string().nullish(), + visual: z.object({ + url: z.string().nullish(), + light: z.string().nullish(), + dark: z.string().nullish() + }).passthrough().nullish(), + bounds: z.object({ + x: z.number(), + y: z.number(), + width: z.number(), + height: z.number(), + unit: z.union([z.literal("px"), z.literal("fraction"), z.literal("inches"), z.literal("cm"), z.literal("mm"), z.literal("pt")]) + }).passthrough() +}).passthrough(); -export const SyncAudiencesRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema, - audiences: z.array(z.object({ - audience_id: z.string(), - name: z.string().nullish(), - description: z.string().nullish(), - audience_type: z.union([z.literal("crm"), z.literal("suppression"), z.literal("lookalike_seed")]).nullish(), - tags: z.array(z.string()).nullish(), - add: z.array(AudienceMemberSchema).nullish(), - remove: z.array(AudienceMemberSchema).nullish(), - delete: z.boolean().nullish(), - consent_basis: ConsentBasisSchema.nullish() - }).passthrough()).nullish(), - delete_missing: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const BaseGroupAssetSchema = z.object({ + asset_id: z.string(), + asset_role: z.string().nullish(), + required: z.boolean(), + overlays: z.array(OverlaySchema).nullish() }).passthrough(); -export const SyncAudiencesErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), +export const HotelItemSchema = z.object({ + hotel_id: z.string(), + name: z.string(), + description: z.string().nullish(), + location: z.object({ + lat: z.number(), + lng: z.number() + }).passthrough(), + address: z.object({ + street: z.string().nullish(), + city: z.string().nullish(), + region: z.string().nullish(), + postal_code: z.string().nullish(), + country: z.string().nullish() + }).passthrough().nullish(), + star_rating: z.number().nullish(), + price: PriceSchema.nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + phone: z.string().nullish(), + amenities: z.array(z.string()).nullish(), + check_in_time: z.string().nullish(), + check_out_time: z.string().nullish(), + tags: z.array(z.string()).nullish(), + valid_from: z.string().nullish(), + valid_to: z.string().nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const MatchIDTypeSchema = z.union([z.literal("hashed_email"), z.literal("hashed_phone"), z.literal("rampid"), z.literal("id5"), z.literal("uid2"), z.literal("euid"), z.literal("pairid"), z.literal("maid"), z.literal("other")]); - -export const SyncAudiencesSuccessSchema = z.object({ - audiences: z.array(z.object({ - audience_id: z.string(), - name: z.string().nullish(), - seller_id: z.string().nullish(), - action: z.union([z.literal("created"), z.literal("updated"), z.literal("unchanged"), z.literal("deleted"), z.literal("failed")]), - status: z.union([z.literal("processing"), z.literal("ready"), z.literal("too_small")]).nullish(), - uploaded_count: z.number().nullish(), - total_uploaded_count: z.number().nullish(), - matched_count: z.number().nullish(), - effective_match_rate: z.number().nullish(), - match_breakdown: z.array(z.object({ - id_type: MatchIDTypeSchema, - submitted: z.number(), - matched: z.number(), - match_rate: z.number() - }).passthrough()).nullish(), - last_synced_at: z.string().nullish(), - minimum_size: z.number().nullish(), - errors: z.array(ErrorSchema).nullish() - }).passthrough()), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), +export const JobItemSchema = z.object({ + job_id: z.string(), + title: z.string(), + company_name: z.string(), + description: z.string(), + location: z.string().nullish(), + employment_type: z.union([z.literal("full_time"), z.literal("part_time"), z.literal("contract"), z.literal("temporary"), z.literal("internship"), z.literal("freelance")]).nullish(), + experience_level: z.union([z.literal("entry_level"), z.literal("mid_level"), z.literal("senior"), z.literal("director"), z.literal("executive")]).nullish(), + salary: z.object({ + min: z.number().nullish(), + max: z.number().nullish(), + currency: z.string(), + period: z.union([z.literal("hour"), z.literal("month"), z.literal("year")]) + }).passthrough().nullish(), + date_posted: z.string().nullish(), + valid_through: z.string().nullish(), + apply_url: z.string().nullish(), + job_functions: z.array(z.string()).nullish(), + industries: z.array(z.string()).nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ValidationModeSchema = z.union([z.literal("strict"), z.literal("lenient")]); +export const MediaBuyFeaturesSchema = z.record(z.string(), z.boolean()).and(z.object({ + inline_creative_management: z.boolean().nullish(), + property_list_filtering: z.boolean().nullish(), + catalog_management: z.boolean().nullish() +}).passthrough()); -export const SyncCatalogsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema, - catalogs: z.array(CatalogSchema).nullish(), - catalog_ids: z.array(z.string()).nullish(), - delete_missing: z.boolean().nullish(), - dry_run: z.boolean().nullish(), - validation_mode: ValidationModeSchema.nullish(), - push_notification_config: PushNotificationConfigSchema.nullish(), - context: ContextObjectSchema.nullish(), +export const OfferingSchema = z.object({ + offering_id: z.string(), + name: z.string(), + description: z.string().nullish(), + tagline: z.string().nullish(), + valid_from: z.string().nullish(), + valid_to: z.string().nullish(), + checkout_url: z.string().nullish(), + landing_url: z.string().nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), + geo_targets: z.object({ + countries: z.array(z.string()).nullish(), + regions: z.array(z.string()).nullish(), + metros: z.array(z.object({ + system: MetroAreaSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + postal_areas: z.array(z.object({ + system: PostalCodeSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish() + }).passthrough().nullish(), + keywords: z.array(z.string()).nullish(), + categories: z.array(z.string()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SyncCatalogsResponseSchema = z.union([SyncCatalogsSuccessSchema, SyncCatalogsErrorSchema]); - -export const CreativeQualitySchema = z.union([z.literal("draft"), z.literal("production")]); +export const MetricTypeSchema = z.union([z.literal("overall_performance"), z.literal("conversion_rate"), z.literal("brand_lift"), z.literal("click_through_rate"), z.literal("completion_rate"), z.literal("viewability"), z.literal("brand_safety"), z.literal("cost_efficiency")]); -export const PreviewOutputFormatSchema = z.union([z.literal("url"), z.literal("html")]); +export const FeedbackSourceSchema = z.union([z.literal("buyer_attribution"), z.literal("third_party_measurement"), z.literal("platform_analytics"), z.literal("verification_partner")]); -export const CreativeManifestSchema = z.object({ - format_id: FormatIDSchema, - assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])), - rights: z.array(RightsConstraintSchema).nullish(), - industry_identifiers: z.array(IndustryIdentifierSchema).nullish(), - provenance: ProvenanceSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const PerformanceFeedbackSchema = z.object({ + feedback_id: z.string(), + media_buy_id: z.string(), + package_id: z.string().nullish(), + creative_id: z.string().nullish(), + measurement_period: z.object({ + start: z.string(), + end: z.string() + }).passthrough(), + performance_index: z.number(), + metric_type: MetricTypeSchema, + feedback_source: FeedbackSourceSchema, + status: z.union([z.literal("accepted"), z.literal("queued"), z.literal("applied"), z.literal("rejected")]), + submitted_at: z.string(), + applied_at: z.string().nullish() }).passthrough(); -export const BuildCreativeSuccessSchema = z.object({ - creative_manifest: CreativeManifestSchema, - sandbox: z.boolean().nullish(), - expires_at: z.string().nullish(), - preview: z.object({ - previews: z.array(z.object({ - preview_id: z.string(), - renders: z.array(PreviewRenderSchema), - input: z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough() - }).passthrough()), - interactive_url: z.string().nullish(), - expires_at: z.string() - }).passthrough().nullish(), - preview_error: ErrorSchema.nullish(), - pricing_option_id: z.string().nullish(), - vendor_cost: z.number().nullish(), - currency: z.string().nullish(), - consumption: CreativeConsumptionSchema.nullish(), - context: ContextObjectSchema.nullish(), +export const PlacementDefinitionSchema = z.object({ + placement_id: z.string(), + name: z.string(), + description: z.string().nullish(), + tags: z.array(z.string()).nullish(), + property_ids: z.array(PropertyIDSchema).nullish(), + property_tags: z.array(PropertyTagSchema).nullish(), + collection_ids: z.array(z.string()).nullish(), + format_ids: z.array(FormatIDSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const BuildCreativeMultiSuccessSchema = z.object({ - creative_manifests: z.array(CreativeManifestSchema), - sandbox: z.boolean().nullish(), - expires_at: z.string().nullish(), - preview: z.object({ - previews: z.array(z.object({ - preview_id: z.string(), - format_id: FormatIDSchema, - renders: z.array(PreviewRenderSchema), - input: z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough() - }).passthrough()), - interactive_url: z.string().nullish(), - expires_at: z.string() - }).passthrough().nullish(), - preview_error: ErrorSchema.nullish(), - pricing_option_id: z.string().nullish(), - vendor_cost: z.number().nullish(), - currency: z.string().nullish(), - consumption: CreativeConsumptionSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); +export const GeographicTargetingLevelSchema = z.union([z.literal("country"), z.literal("region"), z.literal("metro"), z.literal("postal_area")]); -export const PreviewCreativeRequestSchema = z.union([z.object({ - adcp_major_version: z.number().nullish(), - request_type: z.literal("single"), - format_id: FormatIDSchema.nullish(), - creative_manifest: CreativeManifestSchema, - inputs: z.array(z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough()).nullish(), - template_id: z.string().nullish(), - quality: CreativeQualitySchema.nullish(), - output_format: PreviewOutputFormatSchema.nullish(), - item_limit: z.number().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const SignalTargetingSchema = z.union([z.object({ + signal_id: SignalIDSchema, + value_type: z.literal("binary"), + value: z.boolean() }).passthrough(), z.object({ - adcp_major_version: z.number().nullish(), - request_type: z.literal("batch"), - requests: z.array(z.object({ - format_id: FormatIDSchema.nullish(), - creative_manifest: CreativeManifestSchema, - inputs: z.array(z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough()).nullish(), - template_id: z.string().nullish(), - quality: CreativeQualitySchema.nullish(), - output_format: PreviewOutputFormatSchema.nullish(), - item_limit: z.number().nullish() - }).passthrough()), - quality: CreativeQualitySchema.nullish(), - output_format: PreviewOutputFormatSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() + signal_id: SignalIDSchema, + value_type: z.literal("categorical"), + values: z.array(z.string()) }).passthrough(), z.object({ - adcp_major_version: z.number().nullish(), - request_type: z.literal("variant"), - variant_id: z.string(), - creative_id: z.string().nullish(), - output_format: PreviewOutputFormatSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() + signal_id: SignalIDSchema, + value_type: z.literal("numeric"), + min_value: z.number().nullish(), + max_value: z.number().nullish() }).passthrough()]); -export const PreviewCreativeSingleResponseSchema = z.object({ - response_type: z.literal("single"), - previews: z.array(z.object({ - preview_id: z.string(), - renders: z.array(PreviewRenderSchema), - input: z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough() - }).passthrough()), - interactive_url: z.string().nullish(), - expires_at: z.string(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const ProductFiltersSchema = z.object({ + delivery_type: DeliveryTypeSchema.nullish(), + exclusivity: ExclusivitySchema.nullish(), + is_fixed_price: z.boolean().nullish(), + format_ids: z.array(FormatIDSchema).nullish(), + standard_formats_only: z.boolean().nullish(), + min_exposures: z.number().nullish(), + start_date: z.string().nullish(), + end_date: z.string().nullish(), + budget_range: z.record(z.string(), z.unknown()).nullish(), + countries: z.array(z.string()).nullish(), + regions: z.array(z.string()).nullish(), + metros: z.array(z.object({ + system: MetroAreaSystemSchema, + code: z.string() + }).passthrough()).nullish(), + channels: z.array(MediaChannelSchema).nullish(), + required_axe_integrations: z.array(z.string()).nullish(), + trusted_match: z.object({ + providers: z.array(z.object({ + agent_url: z.string(), + context_match: z.boolean().nullish(), + identity_match: z.boolean().nullish() + }).passthrough()).nullish(), + response_types: z.array(TMPResponseTypeSchema).nullish() + }).passthrough().nullish(), + required_features: MediaBuyFeaturesSchema.nullish(), + required_geo_targeting: z.array(z.object({ + level: GeographicTargetingLevelSchema, + system: z.string().nullish() + }).passthrough()).nullish(), + signal_targeting: z.array(SignalTargetingSchema).nullish(), + postal_areas: z.array(z.object({ + system: PostalCodeSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + geo_proximity: z.array(z.record(z.string(), z.unknown())).nullish(), + required_performance_standards: z.array(PerformanceStandardSchema).nullish(), + keywords: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]).nullish() + }).passthrough()).nullish() }).passthrough(); -export const PreviewCreativeVariantResponseSchema = z.object({ - response_type: z.literal("variant"), - variant_id: z.string(), - creative_id: z.string().nullish(), - previews: z.array(z.object({ - preview_id: z.string(), - renders: z.array(PreviewRenderSchema) - }).passthrough()), - manifest: CreativeManifestSchema.nullish(), - expires_at: z.string().nullish(), - context: ContextObjectSchema.nullish(), +export const ProtocolEnvelopeSchema = z.object({ + context_id: z.string().nullish(), + task_id: z.string().nullish(), + status: TaskStatusSchema, + message: z.string().nullish(), + timestamp: z.string().nullish(), + push_notification_config: PushNotificationConfigSchema.nullish(), + governance_context: z.string().nullish(), + payload: z.object({}).passthrough() +}).passthrough(); + +export const RealEstateItemSchema = z.object({ + listing_id: z.string(), + title: z.string(), + address: z.object({ + street: z.string().nullish(), + city: z.string().nullish(), + region: z.string().nullish(), + postal_code: z.string().nullish(), + country: z.string().nullish() + }).passthrough(), + price: PriceSchema.nullish(), + property_type: z.union([z.literal("house"), z.literal("apartment"), z.literal("condo"), z.literal("townhouse"), z.literal("land"), z.literal("commercial")]).nullish(), + listing_type: z.union([z.literal("for_sale"), z.literal("for_rent")]).nullish(), + bedrooms: z.number().nullish(), + bathrooms: z.number().nullish(), + area: z.object({ + value: z.number(), + unit: z.union([z.literal("sqft"), z.literal("sqm")]) + }).passthrough().nullish(), + description: z.string().nullish(), + location: z.object({ + lat: z.number(), + lng: z.number() + }).passthrough().nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + neighborhood: z.string().nullish(), + year_built: z.number().nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PreviewBatchResultSuccessSchema = z.object({ - success: z.literal(true).nullish() +export const ReportingWebhookSchema = z.object({ + url: z.string(), + token: z.string().nullish(), + authentication: z.object({ + schemes: z.array(AuthenticationSchemeSchema), + credentials: z.string() + }).passthrough(), + reporting_frequency: z.union([z.literal("hourly"), z.literal("daily"), z.literal("monthly")]), + requested_metrics: z.array(AvailableMetricSchema).nullish() }).passthrough(); -export const PreviewBatchResultErrorSchema = z.object({ - success: z.literal(false).nullish() +export const VideoAssetRequirementsSchema = z.object({ + min_width: z.number().nullish(), + max_width: z.number().nullish(), + min_height: z.number().nullish(), + max_height: z.number().nullish(), + aspect_ratio: z.string().nullish(), + min_duration_ms: z.number().nullish(), + max_duration_ms: z.number().nullish(), + containers: z.array(z.union([z.literal("mp4"), z.literal("webm"), z.literal("mov"), z.literal("avi"), z.literal("mkv")])).nullish(), + codecs: z.array(z.union([z.literal("h264"), z.literal("h265"), z.literal("vp8"), z.literal("vp9"), z.literal("av1"), z.literal("prores")])).nullish(), + max_file_size_kb: z.number().nullish(), + min_bitrate_kbps: z.number().nullish(), + max_bitrate_kbps: z.number().nullish(), + frame_rates: z.array(z.number()).nullish(), + audio_required: z.boolean().nullish(), + frame_rate_type: z.union([z.literal("constant"), z.literal("variable")]).nullish(), + scan_type: z.union([z.literal("progressive"), z.literal("interlaced")]).nullish(), + gop_type: z.union([z.literal("closed"), z.literal("open")]).nullish(), + min_gop_interval_seconds: z.number().nullish(), + max_gop_interval_seconds: z.number().nullish(), + moov_atom_position: z.union([z.literal("start"), z.literal("end")]).nullish(), + audio_codecs: z.array(z.union([z.literal("aac"), z.literal("pcm"), z.literal("ac3"), z.literal("eac3"), z.literal("mp3"), z.literal("opus"), z.literal("vorbis"), z.literal("flac")])).nullish(), + audio_sample_rates: z.array(z.number()).nullish(), + audio_channels: z.array(z.union([z.literal("mono"), z.literal("stereo"), z.literal("5.1"), z.literal("7.1")])).nullish(), + loudness_lufs: z.number().nullish(), + loudness_tolerance_db: z.number().nullish(), + true_peak_dbfs: z.number().nullish() }).passthrough(); -export const GetCreativeDeliveryRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema.nullish(), - media_buy_ids: z.array(z.string()).nullish(), - creative_ids: z.array(z.string()).nullish(), - start_date: z.string().nullish(), - end_date: z.string().nullish(), - max_variants: z.number().nullish(), - pagination: PaginationRequestSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const AudioAssetRequirementsSchema = z.object({ + min_duration_ms: z.number().nullish(), + max_duration_ms: z.number().nullish(), + formats: z.array(z.union([z.literal("mp3"), z.literal("aac"), z.literal("wav"), z.literal("ogg"), z.literal("flac")])).nullish(), + max_file_size_kb: z.number().nullish(), + sample_rates: z.array(z.number()).nullish(), + channels: z.array(z.union([z.literal("mono"), z.literal("stereo")])).nullish(), + min_bitrate_kbps: z.number().nullish(), + max_bitrate_kbps: z.number().nullish() }).passthrough(); -export const IdentifierSchema = z.object({ - type: PropertyIdentifierTypesSchema, - value: z.string() +export const TextAssetRequirementsSchema = z.object({ + min_length: z.number().nullish(), + max_length: z.number().nullish(), + min_lines: z.number().nullish(), + max_lines: z.number().nullish(), + character_pattern: z.string().nullish(), + prohibited_terms: z.array(z.string()).nullish() }).passthrough(); -export const CreativeVariantSchema = DeliveryMetricsSchema.and(z.object({ - variant_id: z.string(), - manifest: CreativeManifestSchema.nullish(), - generation_context: z.object({ - context_type: z.string().nullish(), - artifact: z.object({ - property_id: IdentifierSchema, - artifact_id: z.string() - }).passthrough().nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough().nullish() -}).passthrough()); +export const MarkdownAssetRequirementsSchema = z.object({ + max_length: z.number().nullish() +}).passthrough(); -export const CreativeSortFieldSchema = z.union([z.literal("created_date"), z.literal("updated_date"), z.literal("name"), z.literal("status"), z.literal("assignment_count")]); +export const HTMLAssetRequirementsSchema = z.object({ + max_file_size_kb: z.number().nullish(), + sandbox: z.union([z.literal("none"), z.literal("iframe"), z.literal("safeframe"), z.literal("fencedframe")]).nullish(), + external_resources_allowed: z.boolean().nullish(), + allowed_external_domains: z.array(z.string()).nullish() +}).passthrough(); -export const SortDirectionSchema = z.union([z.literal("asc"), z.literal("desc")]); +export const CSSAssetRequirementsSchema = z.object({ + max_file_size_kb: z.number().nullish() +}).passthrough(); -export const CreativeFiltersSchema = z.object({ - accounts: z.array(AccountReferenceSchema).nullish(), - statuses: z.array(CreativeStatusSchema).nullish(), - tags: z.array(z.string()).nullish(), - tags_any: z.array(z.string()).nullish(), - name_contains: z.string().nullish(), - creative_ids: z.array(z.string()).nullish(), - created_after: z.string().nullish(), - created_before: z.string().nullish(), - updated_after: z.string().nullish(), - updated_before: z.string().nullish(), - assigned_to_packages: z.array(z.string()).nullish(), - media_buy_ids: z.array(z.string()).nullish(), - unassigned: z.boolean().nullish(), - has_served: z.boolean().nullish(), - concept_ids: z.array(z.string()).nullish(), - format_ids: z.array(FormatIDSchema).nullish(), - has_variables: z.boolean().nullish() +export const JavaScriptAssetRequirementsSchema = z.object({ + max_file_size_kb: z.number().nullish(), + module_type: z.union([z.literal("script"), z.literal("module"), z.literal("iife")]).nullish(), + strict_mode_required: z.boolean().nullish(), + external_resources_allowed: z.boolean().nullish(), + allowed_external_domains: z.array(z.string()).nullish() }).passthrough(); -export const CreativeItemSchema = z.union([z.object({ - asset_kind: z.literal("media"), - asset_type: z.string(), - asset_id: z.string(), - content_uri: z.string() - }).passthrough(), z.object({ - asset_kind: z.literal("text"), - asset_type: z.string(), - asset_id: z.string(), - content: z.union([z.string(), z.array(z.string())]) - }).passthrough()]); +export const VASTAssetRequirementsSchema = z.object({ + vast_version: z.union([z.literal("2.0"), z.literal("3.0"), z.literal("4.0"), z.literal("4.1"), z.literal("4.2")]).nullish() +}).passthrough(); -export const CreativeVariableSchema = z.object({ - variable_id: z.string(), - name: z.string(), - variable_type: z.union([z.literal("text"), z.literal("image"), z.literal("video"), z.literal("audio"), z.literal("url"), z.literal("number"), z.literal("boolean"), z.literal("color"), z.literal("date")]), - default_value: z.string().nullish(), - required: z.boolean().nullish() +export const DAASTAssetRequirementsSchema = z.object({ + daast_version: z.literal("1.0").nullish() }).passthrough(); -export const SyncCreativesRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema, - creatives: z.array(CreativeAssetSchema), - creative_ids: z.array(z.string()).nullish(), - assignments: z.array(z.object({ - creative_id: z.string(), - package_id: z.string(), - weight: z.number().nullish(), - placement_ids: z.array(z.string()).nullish() - }).passthrough()).nullish(), - idempotency_key: z.string().nullish(), - delete_missing: z.boolean().nullish(), - dry_run: z.boolean().nullish(), - validation_mode: ValidationModeSchema.nullish(), - push_notification_config: PushNotificationConfigSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const URLAssetRequirementsSchema = z.object({ + role: z.union([z.literal("clickthrough"), z.literal("landing_page"), z.literal("impression_tracker"), z.literal("click_tracker"), z.literal("viewability_tracker"), z.literal("third_party_tracker")]).nullish(), + protocols: z.array(z.union([z.literal("https"), z.literal("http")])).nullish(), + allowed_domains: z.array(z.string()).nullish(), + max_length: z.number().nullish(), + macro_support: z.boolean().nullish() }).passthrough(); -export const SyncCreativesResponseSchema = z.union([SyncCreativesSuccessSchema, SyncCreativesErrorSchema]); +export const WebhookAssetRequirementsSchema = z.object({ + methods: z.array(z.union([z.literal("GET"), z.literal("POST")])).nullish() +}).passthrough(); -export const DestinationSchema = z.union([z.object({ - type: z.literal("platform"), - platform: z.string(), - account: z.string().nullish() - }).passthrough(), z.object({ - type: z.literal("agent"), - agent_url: z.string(), - account: z.string().nullish() +export const DimensionUnitSchema = z.union([z.literal("px"), z.literal("dp"), z.literal("inches"), z.literal("cm"), z.literal("mm"), z.literal("pt")]); + +export const ImageAssetRequirementsSchema = z.object({ + min_width: z.number().nullish(), + max_width: z.number().nullish(), + min_height: z.number().nullish(), + max_height: z.number().nullish(), + unit: DimensionUnitSchema.nullish(), + aspect_ratio: z.string().nullish(), + formats: z.array(z.union([z.literal("jpg"), z.literal("jpeg"), z.literal("png"), z.literal("gif"), z.literal("webp"), z.literal("svg"), z.literal("avif"), z.literal("tiff"), z.literal("pdf"), z.literal("eps")])).nullish(), + min_dpi: z.number().nullish(), + bleed: z.union([z.object({ + uniform: z.number() + }).passthrough(), z.object({ + top: z.number(), + right: z.number(), + bottom: z.number(), + left: z.number() + }).passthrough()]).nullish(), + color_space: z.union([z.literal("rgb"), z.literal("cmyk"), z.literal("grayscale")]).nullish(), + max_file_size_kb: z.number().nullish(), + transparency_required: z.boolean().nullish(), + animation_allowed: z.boolean().nullish(), + max_animation_duration_ms: z.number().nullish(), + max_weight_grams: z.number().nullish() +}).passthrough(); + +export const ScalarBindingSchema = z.object({ + kind: z.literal("scalar"), + asset_id: z.string(), + catalog_field: z.string(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const AssetPoolBindingSchema = z.object({ + kind: z.literal("asset_pool"), + asset_id: z.string(), + asset_group_id: z.string(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CatalogFieldBindingSchema = z.union([ScalarBindingSchema, AssetPoolBindingSchema, z.object({ + kind: z.literal("catalog_group"), + format_group_id: z.string(), + catalog_item: z.literal(true), + per_item_bindings: z.array(z.union([ScalarBindingSchema, AssetPoolBindingSchema])).nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough()]); +export const AssetRequirementsSchema = z.union([ImageAssetRequirementsSchema, VideoAssetRequirementsSchema, AudioAssetRequirementsSchema, TextAssetRequirementsSchema, MarkdownAssetRequirementsSchema, HTMLAssetRequirementsSchema, CSSAssetRequirementsSchema, JavaScriptAssetRequirementsSchema, VASTAssetRequirementsSchema, DAASTAssetRequirementsSchema, URLAssetRequirementsSchema, WebhookAssetRequirementsSchema]); + +export const ProtocolResponseSchema = z.object({ + message: z.string(), + context_id: z.string().nullish(), + data: z.record(z.string(), z.unknown()).nullish() +}).passthrough(); + +export const SignalValueTypeSchema = z.union([z.literal("binary"), z.literal("categorical"), z.literal("numeric")]); + +export const RestrictedAttributeSchema = z.union([z.literal("racial_ethnic_origin"), z.literal("political_opinions"), z.literal("religious_beliefs"), z.literal("trade_union_membership"), z.literal("health_data"), z.literal("sex_life_sexual_orientation"), z.literal("genetic_data"), z.literal("biometric_data")]); + +export const SignalDefinitionSchema = z.object({ + id: z.string(), + name: z.string(), + description: z.string().nullish(), + value_type: SignalValueTypeSchema, + tags: z.array(z.string()).nullish(), + allowed_values: z.array(z.string()).nullish(), + restricted_attributes: z.array(RestrictedAttributeSchema).nullish(), + policy_categories: z.array(z.string()).nullish(), + range: z.object({ + min: z.number(), + max: z.number(), + unit: z.string().nullish() + }).passthrough().nullish() +}).passthrough(); + export const SignalCatalogTypeSchema = z.union([z.literal("marketplace"), z.literal("custom"), z.literal("owned")]); export const SignalFiltersSchema = z.object({ @@ -2282,60 +2419,219 @@ export const SignalFiltersSchema = z.object({ min_coverage_percentage: z.number().nullish() }).passthrough(); -export const SignalValueTypeSchema = z.union([z.literal("binary"), z.literal("categorical"), z.literal("numeric")]); - -export const ActivationKeySchema = z.union([z.object({ - type: z.literal("segment_id"), - segment_id: z.string() - }).passthrough(), z.object({ - type: z.literal("key_value"), - key: z.string(), - value: z.string() - }).passthrough()]); +export const VendorPricingSchema = z.union([CpmPricingSchema, PercentOfMediaPricingSchema, FlatFeePricingSchema, PerUnitPricingSchema]); -export const DeploymentSchema = z.union([z.object({ - type: z.literal("platform"), - platform: z.string(), - account: z.string().nullish(), - is_live: z.boolean(), - activation_key: ActivationKeySchema.nullish(), - estimated_activation_duration_minutes: z.number().nullish(), - deployed_at: z.string().nullish() - }).passthrough(), z.object({ - type: z.literal("agent"), - agent_url: z.string(), - account: z.string().nullish(), - is_live: z.boolean(), - activation_key: ActivationKeySchema.nullish(), - estimated_activation_duration_minutes: z.number().nullish(), - deployed_at: z.string().nullish() - }).passthrough()]); +export const StartTimingSchema = z.union([z.literal("asap"), z.string()]); -export const ActivateSignalRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - action: z.union([z.literal("activate"), z.literal("deactivate")]).nullish(), - signal_agent_segment_id: z.string(), - destinations: z.array(DestinationSchema), - pricing_option_id: z.string().nullish(), - account: AccountReferenceSchema.nullish(), - idempotency_key: z.string().nullish(), - context: ContextObjectSchema.nullish(), +export const CatchmentSchema = z.object({ + catchment_id: z.string(), + label: z.string().nullish(), + travel_time: z.object({ + value: z.number(), + unit: z.union([z.literal("min"), z.literal("hr")]) + }).passthrough().nullish(), + transport_mode: TransportModeSchema.nullish(), + radius: z.object({ + value: z.number(), + unit: DistanceUnitSchema + }).passthrough().nullish(), + geometry: z.object({ + type: z.union([z.literal("Polygon"), z.literal("MultiPolygon")]), + coordinates: z.array(z.unknown()) + }).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ActivateSignalSuccessSchema = z.object({ - deployments: z.array(DeploymentSchema), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), +export const VehicleItemSchema = z.object({ + vehicle_id: z.string(), + title: z.string(), + make: z.string(), + model: z.string(), + year: z.number(), + price: PriceSchema.nullish(), + condition: z.union([z.literal("new"), z.literal("used"), z.literal("certified_pre_owned")]).nullish(), + vin: z.string().nullish(), + trim: z.string().nullish(), + mileage: z.object({ + value: z.number(), + unit: z.union([z.literal("km"), z.literal("mi")]) + }).passthrough().nullish(), + body_style: z.union([z.literal("sedan"), z.literal("suv"), z.literal("truck"), z.literal("coupe"), z.literal("convertible"), z.literal("wagon"), z.literal("van"), z.literal("hatchback")]).nullish(), + transmission: z.union([z.literal("automatic"), z.literal("manual"), z.literal("cvt")]).nullish(), + fuel_type: z.union([z.literal("gasoline"), z.literal("diesel"), z.literal("electric"), z.literal("hybrid"), z.literal("plug_in_hybrid")]).nullish(), + exterior_color: z.string().nullish(), + interior_color: z.string().nullish(), + location: z.object({ + lat: z.number(), + lng: z.number() + }).passthrough().nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ActivateSignalErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), +export const CreativeFeatureResultSchema = z.object({ + feature_id: z.string(), + value: z.union([z.boolean(), z.number(), z.string()]), + unit: z.string().nullish(), + confidence: z.number().nullish(), + measured_at: z.string().nullish(), + expires_at: z.string().nullish(), + methodology_version: z.string().nullish(), + details: z.object({}).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); +export const AdvertiserIndustrySchema = z.union([z.literal("automotive"), z.literal("automotive.electric_vehicles"), z.literal("automotive.parts_accessories"), z.literal("automotive.luxury"), z.literal("beauty_cosmetics"), z.literal("beauty_cosmetics.skincare"), z.literal("beauty_cosmetics.fragrance"), z.literal("beauty_cosmetics.haircare"), z.literal("cannabis"), z.literal("cpg"), z.literal("cpg.personal_care"), z.literal("cpg.household"), z.literal("dating"), z.literal("education"), z.literal("education.higher_education"), z.literal("education.online_learning"), z.literal("education.k12"), z.literal("energy_utilities"), z.literal("energy_utilities.renewable"), z.literal("fashion_apparel"), z.literal("fashion_apparel.luxury"), z.literal("fashion_apparel.sportswear"), z.literal("finance"), z.literal("finance.banking"), z.literal("finance.insurance"), z.literal("finance.investment"), z.literal("finance.cryptocurrency"), z.literal("food_beverage"), z.literal("food_beverage.alcohol"), z.literal("food_beverage.restaurants"), z.literal("food_beverage.packaged_goods"), z.literal("gambling_betting"), z.literal("gambling_betting.sports_betting"), z.literal("gambling_betting.casino"), z.literal("gaming"), z.literal("gaming.mobile"), z.literal("gaming.console_pc"), z.literal("gaming.esports"), z.literal("government_nonprofit"), z.literal("government_nonprofit.political"), z.literal("government_nonprofit.charity"), z.literal("healthcare"), z.literal("healthcare.pharmaceutical"), z.literal("healthcare.medical_devices"), z.literal("healthcare.wellness"), z.literal("home_garden"), z.literal("home_garden.furniture"), z.literal("home_garden.home_improvement"), z.literal("media_entertainment"), z.literal("media_entertainment.podcasts"), z.literal("media_entertainment.music"), z.literal("media_entertainment.film_tv"), z.literal("media_entertainment.publishing"), z.literal("media_entertainment.live_events"), z.literal("pets"), z.literal("professional_services"), z.literal("professional_services.legal"), z.literal("professional_services.consulting"), z.literal("real_estate"), z.literal("real_estate.residential"), z.literal("real_estate.commercial"), z.literal("recruitment_hr"), z.literal("retail"), z.literal("retail.ecommerce"), z.literal("retail.department_stores"), z.literal("sports_fitness"), z.literal("sports_fitness.equipment"), z.literal("sports_fitness.teams_leagues"), z.literal("technology"), z.literal("technology.software"), z.literal("technology.hardware"), z.literal("technology.ai_ml"), z.literal("telecom"), z.literal("telecom.mobile_carriers"), z.literal("telecom.internet_providers"), z.literal("transportation_logistics"), z.literal("travel_hospitality"), z.literal("travel_hospitality.airlines"), z.literal("travel_hospitality.hotels"), z.literal("travel_hospitality.cruise"), z.literal("travel_hospitality.tourism")]); + +export const AudienceSourceSchema = z.union([z.literal("synced"), z.literal("platform"), z.literal("third_party"), z.literal("lookalike"), z.literal("retargeting"), z.literal("unknown")]); + +export const BrandAgentTypeSchema = z.union([z.literal("brand"), z.literal("rights"), z.literal("measurement"), z.literal("governance"), z.literal("creative"), z.literal("sales"), z.literal("buying"), z.literal("signals")]); + +export const BudgetAuthorityLevelSchema = z.union([z.literal("agent_full"), z.literal("agent_limited"), z.literal("human_required")]); + +export const ConsentBasisSchema = z.union([z.literal("consent"), z.literal("legitimate_interest"), z.literal("contract"), z.literal("legal_obligation")]); + +export const CreativeAgentCapabilitySchema = z.union([z.literal("validation"), z.literal("assembly"), z.literal("generation"), z.literal("preview"), z.literal("delivery")]); + +export const CreativeApprovalStatusSchema = z.union([z.literal("pending_review"), z.literal("approved"), z.literal("rejected")]); + +export const CreativeQualitySchema = z.union([z.literal("draft"), z.literal("production")]); + +export const CreativeSortFieldSchema = z.union([z.literal("created_date"), z.literal("updated_date"), z.literal("name"), z.literal("status"), z.literal("assignment_count")]); + +export const DelegationAuthoritySchema = z.union([z.literal("full"), z.literal("execute_only"), z.literal("propose_only")]); + +export const ErrorCodeSchema = z.union([z.literal("INVALID_REQUEST"), z.literal("AUTH_REQUIRED"), z.literal("RATE_LIMITED"), z.literal("SERVICE_UNAVAILABLE"), z.literal("POLICY_VIOLATION"), z.literal("PRODUCT_NOT_FOUND"), z.literal("PRODUCT_UNAVAILABLE"), z.literal("PROPOSAL_EXPIRED"), z.literal("BUDGET_TOO_LOW"), z.literal("CREATIVE_REJECTED"), z.literal("UNSUPPORTED_FEATURE"), z.literal("AUDIENCE_TOO_SMALL"), z.literal("ACCOUNT_NOT_FOUND"), z.literal("ACCOUNT_SETUP_REQUIRED"), z.literal("ACCOUNT_AMBIGUOUS"), z.literal("ACCOUNT_PAYMENT_REQUIRED"), z.literal("ACCOUNT_SUSPENDED"), z.literal("COMPLIANCE_UNSATISFIED"), z.literal("BUDGET_EXHAUSTED"), z.literal("BUDGET_EXCEEDED"), z.literal("CONFLICT"), z.literal("CREATIVE_DEADLINE_EXCEEDED"), z.literal("INVALID_STATE"), z.literal("MEDIA_BUY_NOT_FOUND"), z.literal("NOT_CANCELLABLE"), z.literal("PACKAGE_NOT_FOUND"), z.literal("SESSION_NOT_FOUND"), z.literal("SESSION_TERMINATED"), z.literal("VALIDATION_ERROR"), z.literal("PRODUCT_EXPIRED"), z.literal("PROPOSAL_NOT_COMMITTED"), z.literal("IO_REQUIRED"), z.literal("TERMS_REJECTED"), z.literal("VERSION_UNSUPPORTED")]); + +export const EscalationSeveritySchema = z.union([z.literal("info"), z.literal("warning"), z.literal("critical")]); + +export const ForecastableMetricSchema = z.union([z.literal("audience_size"), z.literal("reach"), z.literal("frequency"), z.literal("impressions"), z.literal("clicks"), z.literal("spend"), z.literal("views"), z.literal("completed_views"), z.literal("grps"), z.literal("engagements"), z.literal("follows"), z.literal("saves"), z.literal("profile_visits"), z.literal("measured_impressions"), z.literal("downloads"), z.literal("plays")]); + +export const FrequencyCapScopeSchema = z.literal("package"); + +export const GovernanceDomainSchema = z.union([z.literal("campaign"), z.literal("property"), z.literal("creative"), z.literal("content_standards")]); + +export const GovernanceModeSchema = z.union([z.literal("audit"), z.literal("advisory"), z.literal("enforce")]); + +export const GovernancePhaseSchema = z.union([z.literal("purchase"), z.literal("modification"), z.literal("delivery")]); + +export const HistoryEntryTypeSchema = z.union([z.literal("request"), z.literal("response")]); + +export const MatchIDTypeSchema = z.union([z.literal("hashed_email"), z.literal("hashed_phone"), z.literal("rampid"), z.literal("id5"), z.literal("uid2"), z.literal("euid"), z.literal("pairid"), z.literal("maid"), z.literal("other")]); + +export const NotificationTypeSchema = z.union([z.literal("scheduled"), z.literal("final"), z.literal("delayed"), z.literal("adjusted")]); + +export const OutcomeTypeSchema = z.union([z.literal("completed"), z.literal("failed"), z.literal("delivery")]); + +export const PolicyCategorySchema = z.union([z.literal("regulation"), z.literal("standard")]); + +export const PolicyEnforcementLevelSchema = z.union([z.literal("must"), z.literal("should"), z.literal("may")]); + +export const PreviewOutputFormatSchema = z.union([z.literal("url"), z.literal("html")]); + +export const PublisherIdentifierTypesSchema = z.union([z.literal("tag_id"), z.literal("duns"), z.literal("lei"), z.literal("seller_id"), z.literal("gln")]); + +export const PurchaseTypeSchema = z.union([z.literal("media_buy"), z.literal("rights_license"), z.literal("signal_activation"), z.literal("creative_services")]); + +export const SISessionStatusSchema = z.union([z.literal("active"), z.literal("pending_handoff"), z.literal("complete"), z.literal("terminated")]); + +export const SignalSourceSchema = z.union([z.literal("catalog"), z.literal("agent")]); + +export const SortDirectionSchema = z.union([z.literal("asc"), z.literal("desc")]); + +export const SortMetricSchema = z.union([z.literal("impressions"), z.literal("spend"), z.literal("clicks"), z.literal("ctr"), z.literal("views"), z.literal("completed_views"), z.literal("completion_rate"), z.literal("conversions"), z.literal("conversion_value"), z.literal("roas"), z.literal("cost_per_acquisition"), z.literal("new_to_brand_rate"), z.literal("leads"), z.literal("grps"), z.literal("reach"), z.literal("frequency"), z.literal("engagements"), z.literal("follows"), z.literal("saves"), z.literal("profile_visits"), z.literal("engagement_rate"), z.literal("cost_per_click")]); + +export const ValidationModeSchema = z.union([z.literal("strict"), z.literal("lenient")]); + +export const AdCPExtensionFileSchemaSchema = z.object({ + $schema: z.literal("http://json-schema.org/draft-07/schema#"), + $id: z.string(), + title: z.string(), + description: z.string(), + valid_from: z.string(), + valid_until: z.string().nullish(), + docs_url: z.string().nullish(), + type: z.literal("object"), + properties: z.object({}).passthrough(), + required: z.array(z.string()).nullish(), + additionalProperties: z.record(z.string(), z.unknown()).nullish() +}).passthrough(); + +export const AudienceConstraintsSchema = z.object({ + include: z.array(AudienceSelectorSchema).nullish(), + exclude: z.array(AudienceSelectorSchema).nullish() +}).passthrough(); + +export const ExemplarSchema = z.object({ + scenario: z.string(), + explanation: z.string() +}).passthrough(); + +export const PolicyReferenceSchema = z.object({ + policy_id: z.string(), + version: z.string().nullish(), + config: z.object({}).passthrough().nullish() +}).passthrough(); + +export const TargetingOverlaySchema = z.object({ + geo_countries: z.array(z.string()).nullish(), + geo_countries_exclude: z.array(z.string()).nullish(), + geo_regions: z.array(z.string()).nullish(), + geo_regions_exclude: z.array(z.string()).nullish(), + geo_metros: z.array(z.object({ + system: MetroAreaSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + geo_metros_exclude: z.array(z.object({ + system: MetroAreaSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + geo_postal_areas: z.array(z.object({ + system: PostalCodeSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + geo_postal_areas_exclude: z.array(z.object({ + system: PostalCodeSystemSchema, + values: z.array(z.string()) + }).passthrough()).nullish(), + daypart_targets: z.array(DaypartTargetSchema).nullish(), + axe_include_segment: z.string().nullish(), + axe_exclude_segment: z.string().nullish(), + audience_include: z.array(z.string()).nullish(), + audience_exclude: z.array(z.string()).nullish(), + frequency_cap: FrequencyCapSchema.nullish(), + property_list: PropertyListReferenceSchema.nullish(), + collection_list: CollectionListReferenceSchema.nullish(), + collection_list_exclude: CollectionListReferenceSchema.nullish(), + age_restriction: z.object({ + min: z.number(), + verification_required: z.boolean().nullish(), + accepted_methods: z.array(AgeVerificationMethodSchema).nullish() + }).passthrough().nullish(), + device_platform: z.array(DevicePlatformSchema).nullish(), + device_type: z.array(DeviceTypeSchema).nullish(), + device_type_exclude: z.array(DeviceTypeSchema).nullish(), + store_catchments: z.array(z.object({ + catalog_id: z.string(), + store_ids: z.array(z.string()).nullish(), + catchment_ids: z.array(z.string()).nullish() + }).passthrough()).nullish(), + geo_proximity: z.array(z.record(z.string(), z.unknown())).nullish(), + language: z.array(z.string()).nullish(), + keyword_targets: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]), + bid_price: z.number().nullish() + }).passthrough()).nullish(), + negative_keywords: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) + }).passthrough()).nullish() +}).passthrough(); + export const PublisherTagsSourceSchema = z.object({ selection_type: z.literal("publisher_tags"), publisher_domain: z.string(), @@ -2353,8 +2649,6 @@ export const DirectIdentifiersSourceSchema = z.object({ identifiers: z.array(IdentifierSchema) }).passthrough(); -export const BasePropertySourceSchema = z.union([PublisherTagsSourceSchema, PublisherPropertyIDsSourceSchema, DirectIdentifiersSourceSchema]); - export const FeatureRequirementSchema = z.object({ feature_id: z.string(), min_value: z.number().nullish(), @@ -2363,556 +2657,1675 @@ export const FeatureRequirementSchema = z.object({ if_not_covered: z.union([z.literal("exclude"), z.literal("include")]).nullish() }).passthrough(); -export const PropertyListFiltersSchema = z.object({ - countries_all: z.array(z.string()).nullish(), - channels_any: z.array(MediaChannelSchema).nullish(), - property_types: z.array(PropertyTypeSchema).nullish(), - feature_requirements: z.array(FeatureRequirementSchema).nullish(), - exclude_identifiers: z.array(IdentifierSchema).nullish() +export const PropertyErrorSchema = z.object({ + code: z.union([z.literal("PROPERTY_NOT_FOUND"), z.literal("PROPERTY_NOT_MONITORED"), z.literal("LIST_NOT_FOUND"), z.literal("LIST_ACCESS_DENIED"), z.literal("METHODOLOGY_NOT_SUPPORTED"), z.literal("JURISDICTION_NOT_SUPPORTED")]), + property: PropertySchema.nullish(), + message: z.string() }).passthrough(); -export const UpdatePropertyListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - list_id: z.string(), - name: z.string().nullish(), +export const PropertyFeatureDefinitionSchema = z.object({ + feature_id: z.string(), + name: z.string(), description: z.string().nullish(), - base_properties: z.array(BasePropertySourceSchema).nullish(), - filters: PropertyListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - webhook_url: z.string().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish(), - idempotency_key: z.string().nullish() + type: z.union([z.literal("binary"), z.literal("quantitative"), z.literal("categorical")]), + range: z.object({ + min: z.number(), + max: z.number() + }).passthrough().nullish(), + allowed_values: z.array(z.string()).nullish(), + coverage: z.object({ + property_types: z.array(z.string()).nullish(), + countries: z.array(z.string()).nullish() + }).passthrough().nullish(), + methodology_url: z.string(), + methodology_version: z.string().nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetPropertyListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), +export const PropertyFeatureSchema = z.object({ + feature_id: z.string(), + value: z.string(), + source: z.string().nullish() +}).passthrough(); + +export const PropertyListChangedWebhookSchema = z.object({ + event: z.literal("property_list_changed"), list_id: z.string(), - resolve: z.boolean().nullish(), - pagination: z.object({ - max_results: z.number().nullish(), - cursor: z.string().nullish() + list_name: z.string().nullish(), + change_summary: z.object({ + properties_added: z.number().nullish(), + properties_removed: z.number().nullish(), + total_properties: z.number().nullish() }).passthrough().nullish(), - context: ContextObjectSchema.nullish(), + resolved_at: z.string(), + cache_valid_until: z.string().nullish(), + signature: z.string(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListPropertyListsRequestSchema = z.object({ +export const PropertyListFiltersSchema = z.object({ + countries_all: z.array(z.string()).nullish(), + channels_any: z.array(MediaChannelSchema).nullish(), + property_types: z.array(PropertyTypeSchema).nullish(), + feature_requirements: z.array(FeatureRequirementSchema).nullish(), + exclude_identifiers: z.array(IdentifierSchema).nullish() +}).passthrough(); + +export const BasePropertySourceSchema = z.union([PublisherTagsSourceSchema, PublisherPropertyIDsSourceSchema, DirectIdentifiersSourceSchema]); + +export const VendorPricingOptionSchema = z.object({ + pricing_option_id: z.string() +}).passthrough().and(VendorPricingSchema); + +export const SICapabilitiesSchema = z.object({ + modalities: z.object({ + conversational: z.boolean().nullish(), + voice: z.union([z.boolean(), z.object({ + provider: z.string().nullish(), + voice_id: z.string().nullish() + }).passthrough()]).nullish(), + video: z.union([z.boolean(), z.object({ + formats: z.array(z.string()).nullish(), + max_duration_seconds: z.number().nullish() + }).passthrough()]).nullish(), + avatar: z.union([z.boolean(), z.object({ + provider: z.string().nullish(), + avatar_id: z.string().nullish() + }).passthrough()]).nullish() + }).passthrough().nullish(), + components: z.object({ + standard: z.array(z.union([z.literal("text"), z.literal("link"), z.literal("image"), z.literal("product_card"), z.literal("carousel"), z.literal("action_button")])).nullish(), + extensions: z.object({}).passthrough().nullish() + }).passthrough().nullish(), + commerce: z.object({ + acp_checkout: z.boolean().nullish() + }).passthrough().nullish(), + a2ui: z.object({ + supported: z.boolean().nullish(), + catalogs: z.array(z.string()).nullish() + }).passthrough().nullish(), + mcp_apps: z.boolean().nullish() +}).passthrough(); + +export const SIIdentitySchema = z.object({ + consent_granted: z.boolean(), + consent_timestamp: z.string().nullish(), + consent_scope: z.array(z.union([z.literal("name"), z.literal("email"), z.literal("shipping_address"), z.literal("phone"), z.literal("locale")])).nullish(), + privacy_policy_acknowledged: z.object({ + brand_policy_url: z.string().nullish(), + brand_policy_version: z.string().nullish() + }).passthrough().nullish(), + user: z.object({ + email: z.string().nullish(), + name: z.string().nullish(), + locale: z.string().nullish(), + phone: z.string().nullish(), + shipping_address: z.object({ + street: z.string().nullish(), + city: z.string().nullish(), + state: z.string().nullish(), + postal_code: z.string().nullish(), + country: z.string().nullish() + }).passthrough().nullish() + }).passthrough().nullish(), + anonymous_session_id: z.string().nullish() +}).passthrough(); + +export const SIUIElementSchema = z.object({ + type: z.union([z.literal("text"), z.literal("link"), z.literal("image"), z.literal("product_card"), z.literal("carousel"), z.literal("action_button"), z.literal("app_handoff"), z.literal("integration_actions")]), + data: z.object({}).passthrough().nullish() +}).passthrough(); + +export const GetProductsRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - principal: z.string().nullish(), - name_contains: z.string().nullish(), + buying_mode: z.union([z.literal("brief"), z.literal("wholesale"), z.literal("refine")]), + brief: z.string().nullish(), + refine: z.array(z.union([z.object({ + scope: z.literal("request"), + ask: z.string() + }).passthrough(), z.object({ + scope: z.literal("product"), + id: z.string(), + action: z.union([z.literal("include"), z.literal("omit"), z.literal("more_like_this")]), + ask: z.string().nullish() + }).passthrough(), z.object({ + scope: z.literal("proposal"), + id: z.string(), + action: z.union([z.literal("include"), z.literal("omit"), z.literal("finalize")]), + ask: z.string().nullish() + }).passthrough()])).nullish(), + brand: BrandReferenceSchema.nullish(), + catalog: CatalogSchema.nullish(), + account: AccountReferenceSchema.nullish(), + preferred_delivery_types: z.array(DeliveryTypeSchema).nullish(), + filters: ProductFiltersSchema.nullish(), + property_list: PropertyListReferenceSchema.nullish(), + fields: z.array(z.union([z.literal("product_id"), z.literal("name"), z.literal("description"), z.literal("publisher_properties"), z.literal("channels"), z.literal("format_ids"), z.literal("placements"), z.literal("delivery_type"), z.literal("exclusivity"), z.literal("pricing_options"), z.literal("forecast"), z.literal("outcome_measurement"), z.literal("delivery_measurement"), z.literal("reporting_capabilities"), z.literal("creative_policy"), z.literal("catalog_types"), z.literal("metric_optimization"), z.literal("conversion_tracking"), z.literal("data_provider_signals"), z.literal("max_optimization_goals"), z.literal("catalog_match"), z.literal("collections"), z.literal("collection_targeting_allowed"), z.literal("installments"), z.literal("brief_relevance"), z.literal("expires_at"), z.literal("product_card"), z.literal("product_card_detailed"), z.literal("enforced_policies"), z.literal("trusted_match")])).nullish(), + time_budget: DurationSchema.nullish(), pagination: PaginationRequestSchema.nullish(), context: ContextObjectSchema.nullish(), + required_policies: z.array(z.string()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const DeletePropertyListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - list_id: z.string(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish(), - idempotency_key: z.string().nullish() +export const CPMPricingOptionSchema = z.object({ + pricing_option_id: z.string(), + pricing_model: z.literal("cpm"), + currency: z.string(), + fixed_price: z.number().nullish(), + floor_price: z.number().nullish(), + max_bid: z.boolean().nullish(), + price_guidance: PriceGuidanceSchema.nullish(), + min_spend_per_package: z.number().nullish(), + price_breakdown: PriceBreakdownSchema.nullish(), + eligible_adjustments: z.array(PriceAdjustmentKindSchema).nullish() }).passthrough(); -export const DeletePropertyListResponseSchema = z.object({ - deleted: z.boolean(), - list_id: z.string(), - ext: ExtensionObjectSchema.nullish() +export const FlatRatePricingOptionSchema = z.object({ + pricing_option_id: z.string(), + pricing_model: z.literal("flat_rate"), + currency: z.string(), + fixed_price: z.number().nullish(), + floor_price: z.number().nullish(), + price_guidance: PriceGuidanceSchema.nullish(), + parameters: DoohParametersSchema.nullish(), + min_spend_per_package: z.number().nullish(), + price_breakdown: PriceBreakdownSchema.nullish(), + eligible_adjustments: z.array(PriceAdjustmentKindSchema).nullish() }).passthrough(); -export const PublisherCollectionsSourceSchema = z.object({ - selection_type: z.literal("publisher_collections"), - publisher_domain: z.string(), - collection_ids: z.array(z.string()) +export const ProposalSchema = z.object({ + proposal_id: z.string(), + name: z.string(), + description: z.string().nullish(), + allocations: z.array(ProductAllocationSchema), + proposal_status: ProposalStatusSchema.nullish(), + expires_at: z.string().nullish(), + insertion_order: InsertionOrderSchema.nullish(), + total_budget_guidance: z.object({ + min: z.number().nullish(), + recommended: z.number().nullish(), + max: z.number().nullish(), + currency: z.string().nullish() + }).passthrough().nullish(), + brief_alignment: z.string().nullish(), + forecast: DeliveryForecastSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const DistributionIdentifierTypeSchema = z.union([z.literal("apple_podcast_id"), z.literal("spotify_collection_id"), z.literal("rss_url"), z.literal("podcast_guid"), z.literal("amazon_music_id"), z.literal("iheart_id"), z.literal("podcast_index_id"), z.literal("youtube_channel_id"), z.literal("youtube_playlist_id"), z.literal("amazon_title_id"), z.literal("roku_channel_id"), z.literal("pluto_channel_id"), z.literal("tubi_id"), z.literal("peacock_id"), z.literal("tiktok_id"), z.literal("twitch_channel"), z.literal("imdb_id"), z.literal("gracenote_id"), z.literal("eidr_id"), z.literal("domain"), z.literal("substack_id")]); - -export const GenreTaxonomySchema = z.union([z.literal("iab_content_3.0"), z.literal("iab_content_2.2"), z.literal("gracenote"), z.literal("eidr"), z.literal("apple_genres"), z.literal("google_genres"), z.literal("roku"), z.literal("amazon_genres"), z.literal("custom")]); - -export const ProductionQualitySchema = z.union([z.literal("professional"), z.literal("prosumer"), z.literal("ugc")]); +export const PricingOptionSchema = z.union([CPMPricingOptionSchema, VCPMPricingOptionSchema, CPCPricingOptionSchema, CPCVPricingOptionSchema, CPVPricingOptionSchema, CPPPricingOptionSchema, CPAPricingOptionSchema, FlatRatePricingOptionSchema, TimeBasedPricingOptionSchema]); -export const CollectionListFiltersSchema = z.object({ - content_ratings_exclude: z.array(ContentRatingSchema).nullish(), - content_ratings_include: z.array(ContentRatingSchema).nullish(), - genres_exclude: z.array(z.string()).nullish(), - genres_include: z.array(z.string()).nullish(), - genre_taxonomy: GenreTaxonomySchema.nullish(), - kinds: z.array(z.union([z.literal("series"), z.literal("publication"), z.literal("event_series"), z.literal("rotation")])).nullish(), - exclude_distribution_ids: z.array(z.object({ - type: DistributionIdentifierTypeSchema, - value: z.string() - }).passthrough()).nullish(), - production_quality: z.array(ProductionQualitySchema).nullish() +export const ReportingCapabilitiesSchema = z.object({ + available_reporting_frequencies: z.array(ReportingFrequencySchema), + expected_delay_minutes: z.number(), + timezone: z.string(), + supports_webhooks: z.boolean(), + available_metrics: z.array(AvailableMetricSchema), + supports_creative_breakdown: z.boolean().nullish(), + supports_keyword_breakdown: z.boolean().nullish(), + supports_geo_breakdown: GeographicBreakdownSupportSchema.nullish(), + supports_device_type_breakdown: z.boolean().nullish(), + supports_device_platform_breakdown: z.boolean().nullish(), + supports_audience_breakdown: z.boolean().nullish(), + supports_placement_breakdown: z.boolean().nullish(), + date_range_support: z.union([z.literal("date_range"), z.literal("lifetime_only")]), + measurement_windows: z.array(MeasurementWindowSchema).nullish() }).passthrough(); -export const DistributionIDsSourceSchema = z.object({ - selection_type: z.literal("distribution_ids"), - identifiers: z.array(z.object({ - type: DistributionIdentifierTypeSchema, - value: z.string() - }).passthrough()) +export const MeasurementReadinessSchema = z.object({ + status: AssessmentStatusSchema, + required_event_types: z.array(EventTypeSchema).nullish(), + missing_event_types: z.array(EventTypeSchema).nullish(), + issues: z.array(DiagnosticIssueSchema).nullish(), + notes: z.string().nullish() }).passthrough(); -export const PublisherGenresSourceSchema = z.object({ - selection_type: z.literal("publisher_genres"), - publisher_domain: z.string(), - genres: z.array(z.string()), - genre_taxonomy: GenreTaxonomySchema +export const InstallmentDeadlinesSchema = z.object({ + booking_deadline: z.string().nullish(), + cancellation_deadline: z.string().nullish(), + material_deadlines: z.array(MaterialDeadlineSchema).nullish() }).passthrough(); -export const BaseCollectionSourceSchema = z.union([DistributionIDsSourceSchema, PublisherCollectionsSourceSchema, PublisherGenresSourceSchema]); - -export const UpdateCollectionListRequestSchema = z.object({ +export const ListCreativeFormatsRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - list_id: z.string(), - name: z.string().nullish(), - description: z.string().nullish(), - base_collections: z.array(BaseCollectionSourceSchema).nullish(), - filters: CollectionListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - webhook_url: z.string().nullish(), + format_ids: z.array(FormatIDSchema).nullish(), + asset_types: z.array(AssetContentTypeSchema).nullish(), + max_width: z.number().nullish(), + max_height: z.number().nullish(), + min_width: z.number().nullish(), + min_height: z.number().nullish(), + is_responsive: z.boolean().nullish(), + name_search: z.string().nullish(), + wcag_level: WCAGLevelSchema.nullish(), + disclosure_positions: z.array(DisclosurePositionSchema).nullish(), + disclosure_persistence: z.array(DisclosurePersistenceSchema).nullish(), + output_format_ids: z.array(FormatIDSchema).nullish(), + input_format_ids: z.array(FormatIDSchema).nullish(), + pagination: PaginationRequestSchema.nullish(), context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish(), - idempotency_key: z.string().nullish() + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CollectionListSchema = z.object({ - list_id: z.string(), - name: z.string(), - description: z.string().nullish(), - principal: z.string().nullish(), - base_collections: z.array(BaseCollectionSourceSchema).nullish(), - filters: CollectionListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - webhook_url: z.string().nullish(), - cache_duration_hours: z.number().nullish(), - created_at: z.string().nullish(), - updated_at: z.string().nullish(), - collection_count: z.number().nullish() +export const BaseIndividualAssetSchema = z.object({ + item_type: z.literal("individual"), + asset_id: z.string(), + asset_role: z.string().nullish(), + required: z.boolean(), + overlays: z.array(OverlaySchema).nullish() }).passthrough(); -export const GetCollectionListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - list_id: z.string(), - resolve: z.boolean().nullish(), - pagination: z.object({ - max_results: z.number().nullish(), - cursor: z.string().nullish() +export const CreativeBriefSchema = z.object({ + name: z.string(), + objective: z.union([z.literal("awareness"), z.literal("consideration"), z.literal("conversion"), z.literal("retention"), z.literal("engagement")]).nullish(), + tone: z.string().nullish(), + audience: z.string().nullish(), + territory: z.string().nullish(), + messaging: z.object({ + headline: z.string().nullish(), + tagline: z.string().nullish(), + cta: z.string().nullish(), + key_messages: z.array(z.string()).nullish() + }).passthrough().nullish(), + reference_assets: z.array(ReferenceAssetSchema).nullish(), + compliance: z.object({ + required_disclosures: z.array(z.object({ + text: z.string(), + position: DisclosurePositionSchema.nullish(), + jurisdictions: z.array(z.string()).nullish(), + regulation: z.string().nullish(), + min_duration_ms: z.number().nullish(), + language: z.string().nullish(), + persistence: DisclosurePersistenceSchema.nullish() + }).passthrough()).nullish(), + prohibited_claims: z.array(z.string()).nullish() + }).passthrough().nullish() +}).passthrough(); + +export const BriefAssetSchema = CreativeBriefSchema; + +export const PackageSchema = z.object({ + package_id: z.string(), + product_id: z.string().nullish(), + budget: z.number().nullish(), + pacing: PacingSchema.nullish(), + pricing_option_id: z.string().nullish(), + bid_price: z.number().nullish(), + price_breakdown: PriceBreakdownSchema.nullish(), + impressions: z.number().nullish(), + catalogs: z.array(CatalogSchema).nullish(), + format_ids: z.array(FormatIDSchema).nullish(), + targeting_overlay: TargetingOverlaySchema.nullish(), + measurement_terms: MeasurementTermsSchema.nullish(), + performance_standards: z.array(PerformanceStandardSchema).nullish(), + creative_assignments: z.array(CreativeAssignmentSchema).nullish(), + format_ids_to_provide: z.array(FormatIDSchema).nullish(), + optimization_goals: z.array(OptimizationGoalSchema).nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + paused: z.boolean().nullish(), + canceled: z.boolean().nullish(), + cancellation: z.object({ + canceled_at: z.string(), + canceled_by: CanceledBySchema, + reason: z.string().nullish(), + acknowledged_at: z.string().nullish() }).passthrough().nullish(), + agency_estimate_number: z.string().nullish(), + creative_deadline: z.string().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetCollectionListResponseSchema = z.object({ - list: CollectionListSchema, - collections: z.array(z.object({ - collection_rid: z.string().nullish(), - name: z.string(), - distribution_ids: z.array(z.object({ - type: DistributionIdentifierTypeSchema, - value: z.string() - }).passthrough()).nullish(), - content_rating: ContentRatingSchema.nullish(), - genre: z.array(z.string()).nullish(), - genre_taxonomy: GenreTaxonomySchema.nullish(), - kind: z.union([z.literal("series"), z.literal("publication"), z.literal("event_series"), z.literal("rotation")]).nullish() - }).passthrough()).nullish(), - pagination: PaginationResponseSchema.nullish(), - resolved_at: z.string().nullish(), - cache_valid_until: z.string().nullish(), - coverage_gaps: z.record(z.string(), z.array(z.object({ - type: DistributionIdentifierTypeSchema, - value: z.string() - }).passthrough())).nullish(), +export const PlannedDeliverySchema = z.object({ + geo: z.object({ + countries: z.array(z.string()).nullish(), + regions: z.array(z.string()).nullish() + }).passthrough().nullish(), + channels: z.array(MediaChannelSchema).nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + frequency_cap: FrequencyCapSchema.nullish(), + audience_summary: z.string().nullish(), + audience_targeting: z.array(AudienceSelectorSchema).nullish(), + total_budget: z.number().nullish(), + currency: z.string().nullish(), + enforced_policies: z.array(z.string()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListCollectionListsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - principal: z.string().nullish(), - name_contains: z.string().nullish(), - pagination: PaginationRequestSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() +export const CreativeAssetSchema = z.object({ + creative_id: z.string(), + name: z.string(), + format_id: FormatIDSchema, + assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])), + inputs: z.array(z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough()).nullish(), + tags: z.array(z.string()).nullish(), + status: CreativeStatusSchema.nullish(), + weight: z.number().nullish(), + placement_ids: z.array(z.string()).nullish(), + industry_identifiers: z.array(IndustryIdentifierSchema).nullish(), + provenance: ProvenanceSchema.nullish() }).passthrough(); -export const ListCollectionListsResponseSchema = z.object({ - lists: z.array(CollectionListSchema), - pagination: PaginationResponseSchema.nullish(), +export const UpdateMediaBuySuccessSchema = z.object({ + media_buy_id: z.string(), + status: MediaBuyStatusSchema.nullish(), + revision: z.number().nullish(), + implementation_date: z.string().nullish().nullable(), + invoice_recipient: BusinessEntitySchema.nullish(), + affected_packages: z.array(PackageSchema).nullish(), + valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const DeleteCollectionListRequestSchema = z.object({ +export const GetMediaBuysRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - list_id: z.string(), + account: AccountReferenceSchema.nullish(), + media_buy_ids: z.array(z.string()).nullish(), + status_filter: z.union([MediaBuyStatusSchema, z.array(MediaBuyStatusSchema)]).nullish(), + include_snapshot: z.boolean().nullish(), + include_history: z.number().nullish(), + pagination: PaginationRequestSchema.nullish(), context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish(), - idempotency_key: z.string().nullish() + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const DeleteCollectionListResponseSchema = z.object({ - deleted: z.boolean(), - list_id: z.string(), +export const PackageStatusSchema = z.object({ + package_id: z.string(), + product_id: z.string().nullish(), + budget: z.number().nullish(), + currency: z.string().nullish(), + bid_price: z.number().nullish(), + impressions: z.number().nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + paused: z.boolean().nullish(), + canceled: z.boolean().nullish(), + cancellation: z.object({ + canceled_at: z.string(), + canceled_by: CanceledBySchema, + reason: z.string().nullish() + }).passthrough().nullish(), + creative_deadline: z.string().nullish(), + creative_approvals: z.array(z.object({ + creative_id: z.string(), + approval_status: CreativeApprovalStatusSchema.nullish(), + rejection_reason: z.string().nullish() + }).passthrough()).nullish(), + format_ids_pending: z.array(FormatIDSchema).nullish(), + snapshot_unavailable_reason: z.union([z.literal("SNAPSHOT_UNSUPPORTED"), z.literal("SNAPSHOT_TEMPORARILY_UNAVAILABLE"), z.literal("SNAPSHOT_PERMISSION_DENIED")]).nullish(), + snapshot: z.object({ + as_of: z.string(), + staleness_seconds: z.number(), + impressions: z.number(), + spend: z.number(), + currency: z.string().nullish(), + clicks: z.number().nullish(), + pacing_index: z.number().nullish(), + delivery_status: z.union([z.literal("delivering"), z.literal("not_delivering"), z.literal("completed"), z.literal("budget_exhausted"), z.literal("flight_ended"), z.literal("goal_met")]).nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListContentStandardsRequestSchema = z.object({ +export const GetMediaBuyDeliveryRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - channels: z.array(MediaChannelSchema).nullish(), - languages: z.array(z.string()).nullish(), - countries: z.array(z.string()).nullish(), - pagination: PaginationRequestSchema.nullish(), + account: AccountReferenceSchema.nullish(), + media_buy_ids: z.array(z.string()).nullish(), + status_filter: z.union([MediaBuyStatusSchema, z.array(MediaBuyStatusSchema)]).nullish(), + start_date: z.string().nullish(), + end_date: z.string().nullish(), + include_package_daily_breakdown: z.boolean().nullish(), + attribution_window: z.object({ + post_click: DurationSchema.nullish(), + post_view: DurationSchema.nullish(), + model: AttributionModelSchema.nullish() + }).passthrough().nullish(), + reporting_dimensions: z.object({ + geo: z.object({ + geo_level: GeographicTargetingLevelSchema, + system: z.union([MetroAreaSystemSchema, PostalCodeSystemSchema]).nullish(), + limit: z.number().nullish(), + sort_by: SortMetricSchema.nullish() + }).passthrough().nullish(), + device_type: z.object({ + limit: z.number().nullish(), + sort_by: SortMetricSchema.nullish() + }).passthrough().nullish(), + device_platform: z.object({ + limit: z.number().nullish(), + sort_by: SortMetricSchema.nullish() + }).passthrough().nullish(), + audience: z.object({ + limit: z.number().nullish(), + sort_by: SortMetricSchema.nullish() + }).passthrough().nullish(), + placement: z.object({ + limit: z.number().nullish(), + sort_by: SortMetricSchema.nullish() + }).passthrough().nullish() + }).passthrough().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const AssetAccessSchema = z.union([z.object({ - method: z.literal("bearer_token"), - token: z.string() - }).passthrough(), z.object({ - method: z.literal("service_account"), - provider: z.union([z.literal("gcp"), z.literal("aws")]), - credentials: z.object({}).passthrough().nullish() - }).passthrough(), z.object({ - method: z.literal("signed_url") - }).passthrough()]); - -export const ArtifactSchema = z.object({ - property_rid: z.string(), - artifact_id: z.string(), - variant_id: z.string().nullish(), - format_id: FormatIDSchema.nullish(), - url: z.string().nullish(), - published_time: z.string().nullish(), - last_update_time: z.string().nullish(), - assets: z.array(z.union([z.object({ - type: z.literal("text"), - role: z.union([z.literal("title"), z.literal("paragraph"), z.literal("heading"), z.literal("caption"), z.literal("quote"), z.literal("list_item"), z.literal("description")]).nullish(), - content: z.string(), - content_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("text/html"), z.literal("application/json")]).nullish(), - language: z.string().nullish(), - heading_level: z.number().nullish(), - provenance: ProvenanceSchema.nullish() - }).passthrough(), z.object({ - type: z.literal("image"), - url: z.string(), - access: AssetAccessSchema.nullish(), - alt_text: z.string().nullish(), - caption: z.string().nullish(), - width: z.number().nullish(), - height: z.number().nullish(), - provenance: ProvenanceSchema.nullish() - }).passthrough(), z.object({ - type: z.literal("video"), - url: z.string(), - access: AssetAccessSchema.nullish(), - duration_ms: z.number().nullish(), - transcript: z.string().nullish(), - transcript_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("application/json")]).nullish(), - transcript_source: z.union([z.literal("original_script"), z.literal("subtitles"), z.literal("closed_captions"), z.literal("dub"), z.literal("generated")]).nullish(), - thumbnail_url: z.string().nullish(), - provenance: ProvenanceSchema.nullish() - }).passthrough(), z.object({ - type: z.literal("audio"), - url: z.string(), - access: AssetAccessSchema.nullish(), - duration_ms: z.number().nullish(), - transcript: z.string().nullish(), - transcript_format: z.union([z.literal("text/plain"), z.literal("text/markdown"), z.literal("application/json")]).nullish(), - transcript_source: z.union([z.literal("original_script"), z.literal("closed_captions"), z.literal("generated")]).nullish(), - provenance: ProvenanceSchema.nullish() - }).passthrough()])), - metadata: z.object({ - canonical: z.string().nullish(), - author: z.string().nullish(), - keywords: z.string().nullish(), - open_graph: z.object({}).passthrough().nullish(), - twitter_card: z.object({}).passthrough().nullish(), - json_ld: z.array(z.object({}).passthrough()).nullish() +export const GetMediaBuyDeliveryResponseSchema = z.object({ + notification_type: z.union([z.literal("scheduled"), z.literal("final"), z.literal("delayed"), z.literal("adjusted"), z.literal("window_update")]).nullish(), + partial_data: z.boolean().nullish(), + unavailable_count: z.number().nullish(), + sequence_number: z.number().nullish(), + next_expected_at: z.string().nullish(), + reporting_period: z.object({ + start: z.string(), + end: z.string() + }).passthrough(), + currency: z.string().nullish(), + attribution_window: AttributionWindowSchema.nullish(), + aggregated_totals: z.object({ + impressions: z.number(), + spend: z.number(), + clicks: z.number().nullish(), + completed_views: z.number().nullish(), + views: z.number().nullish(), + conversions: z.number().nullish(), + conversion_value: z.number().nullish(), + roas: z.number().nullish(), + new_to_brand_rate: z.number().nullish(), + cost_per_acquisition: z.number().nullish(), + completion_rate: z.number().nullish(), + reach: z.number().nullish(), + reach_unit: ReachUnitSchema.nullish(), + frequency: z.number().nullish(), + media_buy_count: z.number() }).passthrough().nullish(), - provenance: ProvenanceSchema.nullish(), - identifiers: z.object({ - apple_podcast_id: z.string().nullish(), - spotify_collection_id: z.string().nullish(), - podcast_guid: z.string().nullish(), - youtube_video_id: z.string().nullish(), - rss_url: z.string().nullish() - }).passthrough().nullish() -}).passthrough(); - -export const GetContentStandardsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - standards_id: z.string(), + media_buy_deliveries: z.array(z.object({ + media_buy_id: z.string(), + status: z.union([z.literal("pending_creatives"), z.literal("pending_start"), z.literal("pending"), z.literal("active"), z.literal("paused"), z.literal("completed"), z.literal("rejected"), z.literal("canceled"), z.literal("failed"), z.literal("reporting_delayed")]), + expected_availability: z.string().nullish(), + is_adjusted: z.boolean().nullish(), + pricing_model: PricingModelSchema.nullish(), + totals: DeliveryMetricsSchema.and(z.object({ + effective_rate: z.number().nullish() + }).passthrough()), + by_package: z.array(DeliveryMetricsSchema.and(z.object({ + package_id: z.string(), + pacing_index: z.number().nullish(), + pricing_model: PricingModelSchema.nullish(), + rate: z.number().nullish(), + currency: z.string().nullish(), + delivery_status: z.union([z.literal("delivering"), z.literal("completed"), z.literal("budget_exhausted"), z.literal("flight_ended"), z.literal("goal_met")]).nullish(), + paused: z.boolean().nullish(), + is_final: z.boolean().nullish(), + measurement_window: z.string().nullish(), + supersedes_window: z.string().nullish(), + by_catalog_item: z.array(DeliveryMetricsSchema.and(z.object({ + content_id: z.string().nullish(), + content_id_type: ContentIDTypeSchema.nullish() + }).passthrough())).nullish(), + by_creative: z.array(DeliveryMetricsSchema.and(z.object({ + creative_id: z.string(), + weight: z.number().nullish() + }).passthrough())).nullish(), + by_keyword: z.array(DeliveryMetricsSchema.and(z.object({ + keyword: z.string().nullish(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]).nullish() + }).passthrough())).nullish(), + by_geo: z.array(DeliveryMetricsSchema.and(z.object({ + geo_level: GeographicTargetingLevelSchema.nullish(), + system: z.string().nullish(), + geo_code: z.string().nullish(), + geo_name: z.string().nullish() + }).passthrough())).nullish(), + by_geo_truncated: z.boolean().nullish(), + by_device_type: z.array(DeliveryMetricsSchema.and(z.object({ + device_type: DeviceTypeSchema.nullish() + }).passthrough())).nullish(), + by_device_type_truncated: z.boolean().nullish(), + by_device_platform: z.array(DeliveryMetricsSchema.and(z.object({ + device_platform: DevicePlatformSchema.nullish() + }).passthrough())).nullish(), + by_device_platform_truncated: z.boolean().nullish(), + by_audience: z.array(DeliveryMetricsSchema.and(z.object({ + audience_id: z.string().nullish(), + audience_source: AudienceSourceSchema.nullish(), + audience_name: z.string().nullish() + }).passthrough())).nullish(), + by_audience_truncated: z.boolean().nullish(), + by_placement: z.array(DeliveryMetricsSchema.and(z.object({ + placement_id: z.string().nullish(), + placement_name: z.string().nullish() + }).passthrough())).nullish(), + by_placement_truncated: z.boolean().nullish(), + daily_breakdown: z.array(z.object({ + date: z.string(), + impressions: z.number(), + spend: z.number(), + conversions: z.number().nullish(), + conversion_value: z.number().nullish(), + roas: z.number().nullish(), + new_to_brand_rate: z.number().nullish() + }).passthrough()).nullish() + }).passthrough())), + daily_breakdown: z.array(z.object({ + date: z.string(), + impressions: z.number(), + spend: z.number(), + conversions: z.number().nullish(), + conversion_value: z.number().nullish(), + roas: z.number().nullish(), + new_to_brand_rate: z.number().nullish() + }).passthrough()).nullish() + }).passthrough()), + errors: z.array(ErrorSchema).nullish(), + sandbox: z.boolean().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreateContentStandardsRequestSchema = z.object({ +export const ProvidePerformanceFeedbackRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - scope: z.object({ - countries_all: z.array(z.string()).nullish(), - channels_any: z.array(MediaChannelSchema).nullish(), - languages_any: z.array(z.string()), - description: z.string().nullish() - }).passthrough(), - registry_policy_ids: z.array(z.string()).nullish(), - policy: z.string(), - calibration_exemplars: z.object({ - pass: z.array(z.union([z.object({ - type: z.literal("url"), - value: z.string(), - language: z.string().nullish() - }).passthrough(), ArtifactSchema])).nullish(), - fail: z.array(z.union([z.object({ - type: z.literal("url"), - value: z.string(), - language: z.string().nullish() - }).passthrough(), ArtifactSchema])).nullish() - }).passthrough().nullish(), + media_buy_id: z.string(), idempotency_key: z.string().nullish(), + measurement_period: DatetimeRangeSchema, + performance_index: z.number(), + package_id: z.string().nullish(), + creative_id: z.string().nullish(), + metric_type: MetricTypeSchema.nullish(), + feedback_source: FeedbackSourceSchema.nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreateContentStandardsResponseSchema = z.union([z.object({ - standards_id: z.string(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - conflicting_standards_id: z.string().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const UpdateContentStandardsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - standards_id: z.string(), - scope: z.object({ - countries_all: z.array(z.string()).nullish(), - channels_any: z.array(MediaChannelSchema).nullish(), - languages_any: z.array(z.string()).nullish(), - description: z.string().nullish() - }).passthrough().nullish(), - registry_policy_ids: z.array(z.string()).nullish(), - policy: z.string().nullish(), - calibration_exemplars: z.object({ - pass: z.array(z.union([z.object({ - type: z.literal("url"), - value: z.string(), - language: z.string().nullish() - }).passthrough(), ArtifactSchema])).nullish(), - fail: z.array(z.union([z.object({ - type: z.literal("url"), - value: z.string(), - language: z.string().nullish() - }).passthrough(), ArtifactSchema])).nullish() - }).passthrough().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish(), - idempotency_key: z.string().nullish() -}).passthrough(); - -export const UpdateContentStandardsSuccessSchema = z.object({ +export const ProvidePerformanceFeedbackSuccessSchema = z.object({ success: z.literal(true), - standards_id: z.string(), + sandbox: z.boolean().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const UpdateContentStandardsErrorSchema = z.object({ - success: z.literal(false), +export const ProvidePerformanceFeedbackErrorSchema = z.object({ errors: z.array(ErrorSchema), - conflicting_standards_id: z.string().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CalibrateContentRequestSchema = z.object({ +export const SyncEventSourcesRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - standards_id: z.string(), - artifact: ArtifactSchema, - idempotency_key: z.string().nullish() + account: AccountReferenceSchema, + event_sources: z.array(z.object({ + event_source_id: z.string(), + name: z.string().nullish(), + event_types: z.array(EventTypeSchema).nullish(), + allowed_domains: z.array(z.string()).nullish() + }).passthrough()).nullish(), + delete_missing: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CalibrateContentResponseSchema = z.union([z.object({ - verdict: z.union([z.literal("pass"), z.literal("fail")]), - confidence: z.number().nullish(), - explanation: z.string().nullish(), - features: z.array(z.object({ - feature_id: z.string(), - status: z.union([z.literal("passed"), z.literal("failed"), z.literal("warning"), z.literal("unevaluated")]), - explanation: z.string().nullish() - }).passthrough()).nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const ValidateContentDeliveryRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - standards_id: z.string(), - records: z.array(z.object({ - record_id: z.string(), - media_buy_id: z.string().nullish(), - timestamp: z.string().nullish(), - artifact: ArtifactSchema, - country: z.string().nullish(), - channel: z.string().nullish(), - brand_context: z.object({ - brand_id: z.string().nullish(), - sku_id: z.string().nullish() - }).passthrough().nullish() +export const SyncEventSourcesSuccessSchema = z.object({ + event_sources: z.array(z.object({ + event_source_id: z.string(), + name: z.string().nullish(), + seller_id: z.string().nullish(), + event_types: z.array(EventTypeSchema).nullish(), + action_source: ActionSourceSchema.nullish(), + managed_by: z.union([z.literal("buyer"), z.literal("seller")]).nullish(), + setup: z.object({ + snippet: z.string().nullish(), + snippet_type: z.union([z.literal("javascript"), z.literal("html"), z.literal("pixel_url"), z.literal("server_only")]).nullish(), + instructions: z.string().nullish() + }).passthrough().nullish(), + action: z.union([z.literal("created"), z.literal("updated"), z.literal("unchanged"), z.literal("deleted"), z.literal("failed")]), + health: EventSourceHealthSchema.nullish(), + errors: z.array(ErrorSchema).nullish() }).passthrough()), - feature_ids: z.array(z.string()).nullish(), - include_passed: z.boolean().nullish(), + sandbox: z.boolean().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ValidateContentDeliveryResponseSchema = z.union([z.object({ - summary: z.object({ - total_records: z.number(), - passed_records: z.number(), - failed_records: z.number() - }).passthrough(), - results: z.array(z.object({ - record_id: z.string(), - verdict: z.union([z.literal("pass"), z.literal("fail")]), - features: z.array(z.object({ - feature_id: z.string(), - status: z.union([z.literal("passed"), z.literal("failed"), z.literal("warning"), z.literal("unevaluated")]), - value: z.unknown().nullish(), - message: z.string().nullish(), - rule_id: z.string().nullish() - }).passthrough()).nullish() - }).passthrough()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const GetMediaBuyArtifactsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema.nullish(), - media_buy_id: z.string(), - package_ids: z.array(z.string()).nullish(), - failures_only: z.boolean().nullish(), - time_range: z.object({ - start: z.string().nullish(), - end: z.string().nullish() - }).passthrough().nullish(), - pagination: z.object({ - max_results: z.number().nullish(), - cursor: z.string().nullish() - }).passthrough().nullish(), +export const SyncEventSourcesErrorSchema = z.object({ + errors: z.array(ErrorSchema), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetMediaBuyArtifactsResponseSchema = z.union([z.object({ - media_buy_id: z.string(), - artifacts: z.array(z.object({ - record_id: z.string(), - timestamp: z.string().nullish(), - package_id: z.string().nullish(), - artifact: ArtifactSchema, - country: z.string().nullish(), - channel: z.string().nullish(), - brand_context: z.object({ - brand_id: z.string().nullish(), - sku_id: z.string().nullish() - }).passthrough().nullish(), - local_verdict: z.union([z.literal("pass"), z.literal("fail"), z.literal("unevaluated")]).nullish() - }).passthrough()), - collection_info: z.object({ - total_deliveries: z.number().nullish(), - total_collected: z.number().nullish(), - returned_count: z.number().nullish(), - effective_rate: z.number().nullish() - }).passthrough().nullish(), - pagination: PaginationResponseSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const GetCreativeFeaturesRequestSchema = z.object({ +export const LogEventRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - creative_manifest: CreativeManifestSchema, - feature_ids: z.array(z.string()).nullish(), - account: AccountReferenceSchema.nullish(), + event_source_id: z.string(), + test_event_code: z.string().nullish(), + events: z.array(EventSchema), + idempotency_key: z.string().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreativeFeatureResultSchema = z.object({ - feature_id: z.string(), - value: z.union([z.boolean(), z.number(), z.string()]), - unit: z.string().nullish(), - confidence: z.number().nullish(), - measured_at: z.string().nullish(), - expires_at: z.string().nullish(), - methodology_version: z.string().nullish(), - details: z.object({}).passthrough().nullish(), +export const LogEventSuccessSchema = z.object({ + events_received: z.number(), + events_processed: z.number(), + partial_failures: z.array(z.object({ + event_id: z.string(), + code: z.string(), + message: z.string() + }).passthrough()).nullish(), + warnings: z.array(z.string()).nullish(), + match_quality: z.number().nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const BudgetAuthorityLevelSchema = z.union([z.literal("agent_full"), z.literal("agent_limited"), z.literal("human_required")]); +export const LogEventErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const RestrictedAttributeSchema = z.union([z.literal("racial_ethnic_origin"), z.literal("political_opinions"), z.literal("religious_beliefs"), z.literal("trade_union_membership"), z.literal("health_data"), z.literal("sex_life_sexual_orientation"), z.literal("genetic_data"), z.literal("biometric_data")]); +export const AudienceMemberSchema = z.object({ + external_id: z.string(), + hashed_email: z.string().nullish(), + hashed_phone: z.string().nullish(), + uids: z.array(z.object({ + type: UIDTypeSchema, + value: z.string() + }).passthrough()).nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const DelegationAuthoritySchema = z.union([z.literal("full"), z.literal("execute_only"), z.literal("propose_only")]); +export const SyncAudiencesRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema, + audiences: z.array(z.object({ + audience_id: z.string(), + name: z.string().nullish(), + description: z.string().nullish(), + audience_type: z.union([z.literal("crm"), z.literal("suppression"), z.literal("lookalike_seed")]).nullish(), + tags: z.array(z.string()).nullish(), + add: z.array(AudienceMemberSchema).nullish(), + remove: z.array(AudienceMemberSchema).nullish(), + delete: z.boolean().nullish(), + consent_basis: ConsentBasisSchema.nullish() + }).passthrough()).nullish(), + delete_missing: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const AudienceConstraintsSchema = z.object({ - include: z.array(AudienceSelectorSchema).nullish(), - exclude: z.array(AudienceSelectorSchema).nullish() +export const SyncAudiencesSuccessSchema = z.object({ + audiences: z.array(z.object({ + audience_id: z.string(), + name: z.string().nullish(), + seller_id: z.string().nullish(), + action: z.union([z.literal("created"), z.literal("updated"), z.literal("unchanged"), z.literal("deleted"), z.literal("failed")]), + status: z.union([z.literal("processing"), z.literal("ready"), z.literal("too_small")]).nullish(), + uploaded_count: z.number().nullish(), + total_uploaded_count: z.number().nullish(), + matched_count: z.number().nullish(), + effective_match_rate: z.number().nullish(), + match_breakdown: z.array(z.object({ + id_type: MatchIDTypeSchema, + submitted: z.number(), + matched: z.number(), + match_rate: z.number() + }).passthrough()).nullish(), + last_synced_at: z.string().nullish(), + minimum_size: z.number().nullish(), + errors: z.array(ErrorSchema).nullish() + }).passthrough()), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PolicyEnforcementLevelSchema = z.union([z.literal("must"), z.literal("should"), z.literal("may")]); +export const SyncAudiencesErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const SyncPlansResponseSchema = z.object({ - plans: z.array(z.object({ - plan_id: z.string(), - status: z.union([z.literal("active"), z.literal("error")]), - version: z.number(), - categories: z.array(z.object({ - category_id: z.string(), - status: z.union([z.literal("active"), z.literal("inactive")]) - }).passthrough()).nullish(), - resolved_policies: z.array(z.object({ - policy_id: z.string(), - source: z.union([z.literal("explicit"), z.literal("auto_applied")]), - enforcement: PolicyEnforcementLevelSchema, - reason: z.string().nullish() - }).passthrough()).nullish() - }).passthrough()) +export const SyncCatalogsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema, + catalogs: z.array(CatalogSchema).nullish(), + catalog_ids: z.array(z.string()).nullish(), + delete_missing: z.boolean().nullish(), + dry_run: z.boolean().nullish(), + validation_mode: ValidationModeSchema.nullish(), + push_notification_config: PushNotificationConfigSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PurchaseTypeSchema = z.union([z.literal("media_buy"), z.literal("rights_license"), z.literal("signal_activation"), z.literal("creative_services")]); +export const SyncCatalogsResponseSchema = z.union([SyncCatalogsSuccessSchema, SyncCatalogsErrorSchema]); -export const OutcomeTypeSchema = z.union([z.literal("completed"), z.literal("failed"), z.literal("delivery")]); +export const CreativeManifestSchema = z.object({ + format_id: FormatIDSchema, + assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])), + rights: z.array(RightsConstraintSchema).nullish(), + industry_identifiers: z.array(IndustryIdentifierSchema).nullish(), + provenance: ProvenanceSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const ReportPlanOutcomeRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - plan_id: z.string(), - check_id: z.string().nullish(), - idempotency_key: z.string().nullish(), - purchase_type: PurchaseTypeSchema.nullish(), - outcome: OutcomeTypeSchema, - seller_response: z.object({ - seller_reference: z.string().nullish(), - committed_budget: z.number().nullish(), +export const BuildCreativeSuccessSchema = z.object({ + creative_manifest: CreativeManifestSchema, + sandbox: z.boolean().nullish(), + expires_at: z.string().nullish(), + preview: z.object({ + previews: z.array(z.object({ + preview_id: z.string(), + renders: z.array(PreviewRenderSchema), + input: z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough() + }).passthrough()), + interactive_url: z.string().nullish(), + expires_at: z.string() + }).passthrough().nullish(), + preview_error: ErrorSchema.nullish(), + pricing_option_id: z.string().nullish(), + vendor_cost: z.number().nullish(), + currency: z.string().nullish(), + consumption: CreativeConsumptionSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const BuildCreativeMultiSuccessSchema = z.object({ + creative_manifests: z.array(CreativeManifestSchema), + sandbox: z.boolean().nullish(), + expires_at: z.string().nullish(), + preview: z.object({ + previews: z.array(z.object({ + preview_id: z.string(), + format_id: FormatIDSchema, + renders: z.array(PreviewRenderSchema), + input: z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough() + }).passthrough()), + interactive_url: z.string().nullish(), + expires_at: z.string() + }).passthrough().nullish(), + preview_error: ErrorSchema.nullish(), + pricing_option_id: z.string().nullish(), + vendor_cost: z.number().nullish(), + currency: z.string().nullish(), + consumption: CreativeConsumptionSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const PreviewCreativeRequestSchema = z.union([z.object({ + adcp_major_version: z.number().nullish(), + request_type: z.literal("single"), + format_id: FormatIDSchema.nullish(), + creative_manifest: CreativeManifestSchema, + inputs: z.array(z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough()).nullish(), + template_id: z.string().nullish(), + quality: CreativeQualitySchema.nullish(), + output_format: PreviewOutputFormatSchema.nullish(), + item_limit: z.number().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + adcp_major_version: z.number().nullish(), + request_type: z.literal("batch"), + requests: z.array(z.object({ + format_id: FormatIDSchema.nullish(), + creative_manifest: CreativeManifestSchema, + inputs: z.array(z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough()).nullish(), + template_id: z.string().nullish(), + quality: CreativeQualitySchema.nullish(), + output_format: PreviewOutputFormatSchema.nullish(), + item_limit: z.number().nullish() + }).passthrough()), + quality: CreativeQualitySchema.nullish(), + output_format: PreviewOutputFormatSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + adcp_major_version: z.number().nullish(), + request_type: z.literal("variant"), + variant_id: z.string(), + creative_id: z.string().nullish(), + output_format: PreviewOutputFormatSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const PreviewCreativeSingleResponseSchema = z.object({ + response_type: z.literal("single"), + previews: z.array(z.object({ + preview_id: z.string(), + renders: z.array(PreviewRenderSchema), + input: z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough() + }).passthrough()), + interactive_url: z.string().nullish(), + expires_at: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const PreviewCreativeVariantResponseSchema = z.object({ + response_type: z.literal("variant"), + variant_id: z.string(), + creative_id: z.string().nullish(), + previews: z.array(z.object({ + preview_id: z.string(), + renders: z.array(PreviewRenderSchema) + }).passthrough()), + manifest: CreativeManifestSchema.nullish(), + expires_at: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const PreviewBatchResultSuccessSchema = z.object({ + success: z.literal(true).nullish() +}).passthrough(); + +export const PreviewBatchResultErrorSchema = z.object({ + success: z.literal(false).nullish() +}).passthrough(); + +export const GetCreativeDeliveryRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema.nullish(), + media_buy_ids: z.array(z.string()).nullish(), + creative_ids: z.array(z.string()).nullish(), + start_date: z.string().nullish(), + end_date: z.string().nullish(), + max_variants: z.number().nullish(), + pagination: PaginationRequestSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CreativeVariantSchema = DeliveryMetricsSchema.and(z.object({ + variant_id: z.string(), + manifest: CreativeManifestSchema.nullish(), + generation_context: z.object({ + context_type: z.string().nullish(), + artifact: z.object({ + property_id: IdentifierSchema, + artifact_id: z.string() + }).passthrough().nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough().nullish() +}).passthrough()); + +export const GetCreativeDeliveryResponseSchema = z.object({ + account_id: z.string().nullish(), + media_buy_id: z.string().nullish(), + currency: z.string(), + reporting_period: z.object({ + start: z.string(), + end: z.string(), + timezone: z.string().nullish() + }).passthrough(), + creatives: z.array(z.object({ + creative_id: z.string(), + media_buy_id: z.string().nullish(), + format_id: FormatIDSchema.nullish(), + totals: DeliveryMetricsSchema.nullish(), + variant_count: z.number().nullish(), + variants: z.array(CreativeVariantSchema) + }).passthrough()), + pagination: z.object({ + limit: z.number(), + offset: z.number(), + has_more: z.boolean(), + total: z.number().nullish() + }).passthrough().nullish(), + errors: z.array(ErrorSchema).nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListCreativesRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + filters: CreativeFiltersSchema.nullish(), + sort: z.object({ + field: CreativeSortFieldSchema.nullish(), + direction: SortDirectionSchema.nullish() + }).passthrough().nullish(), + pagination: PaginationRequestSchema.nullish(), + include_assignments: z.boolean().nullish(), + include_snapshot: z.boolean().nullish(), + include_items: z.boolean().nullish(), + include_variables: z.boolean().nullish(), + include_pricing: z.boolean().nullish(), + account: AccountReferenceSchema.nullish(), + fields: z.array(z.union([z.literal("creative_id"), z.literal("name"), z.literal("format_id"), z.literal("status"), z.literal("created_date"), z.literal("updated_date"), z.literal("tags"), z.literal("assignments"), z.literal("snapshot"), z.literal("items"), z.literal("variables"), z.literal("concept"), z.literal("pricing_options")])).nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListCreativesResponseSchema = z.object({ + query_summary: z.object({ + total_matching: z.number(), + returned: z.number(), + filters_applied: z.array(z.string()).nullish(), + sort_applied: z.object({ + field: z.string().nullish(), + direction: SortDirectionSchema.nullish() + }).passthrough().nullish() + }).passthrough(), + pagination: PaginationResponseSchema, + creatives: z.array(z.object({ + creative_id: z.string(), + account: AccountSchema.nullish(), + name: z.string(), + format_id: FormatIDSchema, + status: CreativeStatusSchema, + created_date: z.string(), + updated_date: z.string(), + assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])).nullish(), + tags: z.array(z.string()).nullish(), + concept_id: z.string().nullish(), + concept_name: z.string().nullish(), + variables: z.array(CreativeVariableSchema).nullish(), + assignments: z.object({ + assignment_count: z.number(), + assigned_packages: z.array(z.object({ + package_id: z.string(), + assigned_date: z.string() + }).passthrough()).nullish() + }).passthrough().nullish(), + snapshot: z.object({ + as_of: z.string(), + staleness_seconds: z.number(), + impressions: z.number(), + last_served: z.string().nullish() + }).passthrough().nullish(), + snapshot_unavailable_reason: z.union([z.literal("SNAPSHOT_UNSUPPORTED"), z.literal("SNAPSHOT_TEMPORARILY_UNAVAILABLE"), z.literal("SNAPSHOT_PERMISSION_DENIED")]).nullish(), + items: z.array(CreativeItemSchema).nullish(), + pricing_options: z.array(VendorPricingOptionSchema).nullish() + }).passthrough()), + format_summary: z.record(z.string(), z.number()).nullish(), + status_summary: z.object({ + processing: z.number().nullish(), + approved: z.number().nullish(), + pending_review: z.number().nullish(), + rejected: z.number().nullish(), + archived: z.number().nullish() + }).passthrough().nullish(), + errors: z.array(ErrorSchema).nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const SyncCreativesRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema, + creatives: z.array(CreativeAssetSchema), + creative_ids: z.array(z.string()).nullish(), + assignments: z.array(z.object({ + creative_id: z.string(), + package_id: z.string(), + weight: z.number().nullish(), + placement_ids: z.array(z.string()).nullish() + }).passthrough()).nullish(), + idempotency_key: z.string().nullish(), + delete_missing: z.boolean().nullish(), + dry_run: z.boolean().nullish(), + validation_mode: ValidationModeSchema.nullish(), + push_notification_config: PushNotificationConfigSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const SyncCreativesResponseSchema = z.union([SyncCreativesSuccessSchema, SyncCreativesErrorSchema]); + +export const GetSignalsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema.nullish(), + signal_spec: z.string().nullish(), + signal_ids: z.array(SignalIDSchema).nullish(), + destinations: z.array(DestinationSchema).nullish(), + countries: z.array(z.string()).nullish(), + filters: SignalFiltersSchema.nullish(), + max_results: z.number().nullish(), + pagination: PaginationRequestSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetSignalsResponseSchema = z.object({ + signals: z.array(z.object({ + signal_id: SignalIDSchema.nullish(), + signal_agent_segment_id: z.string(), + name: z.string(), + description: z.string(), + value_type: SignalValueTypeSchema.nullish(), + categories: z.array(z.string()).nullish(), + range: z.object({ + min: z.number(), + max: z.number() + }).passthrough().nullish(), + signal_type: SignalCatalogTypeSchema, + data_provider: z.string(), + coverage_percentage: z.number(), + deployments: z.array(DeploymentSchema), + pricing_options: z.array(VendorPricingOptionSchema) + }).passthrough()), + errors: z.array(ErrorSchema).nullish(), + pagination: PaginationResponseSchema.nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ActivateSignalRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + action: z.union([z.literal("activate"), z.literal("deactivate")]).nullish(), + signal_agent_segment_id: z.string(), + destinations: z.array(DestinationSchema), + pricing_option_id: z.string().nullish(), + account: AccountReferenceSchema.nullish(), + idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ActivateSignalSuccessSchema = z.object({ + deployments: z.array(DeploymentSchema), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ActivateSignalErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CreatePropertyListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + name: z.string(), + description: z.string().nullish(), + base_properties: z.array(BasePropertySourceSchema).nullish(), + filters: PropertyListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const PropertyListSchema = z.object({ + list_id: z.string(), + name: z.string(), + description: z.string().nullish(), + principal: z.string().nullish(), + base_properties: z.array(BasePropertySourceSchema).nullish(), + filters: PropertyListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + webhook_url: z.string().nullish(), + cache_duration_hours: z.number().nullish(), + created_at: z.string().nullish(), + updated_at: z.string().nullish(), + property_count: z.number().nullish(), + pricing_options: z.array(VendorPricingOptionSchema).nullish() +}).passthrough(); + +export const UpdatePropertyListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + name: z.string().nullish(), + description: z.string().nullish(), + base_properties: z.array(BasePropertySourceSchema).nullish(), + filters: PropertyListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + webhook_url: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish(), + idempotency_key: z.string().nullish() +}).passthrough(); + +export const UpdatePropertyListResponseSchema = z.object({ + list: PropertyListSchema, + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetPropertyListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + resolve: z.boolean().nullish(), + pagination: z.object({ + max_results: z.number().nullish(), + cursor: z.string().nullish() + }).passthrough().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetPropertyListResponseSchema = z.object({ + list: PropertyListSchema, + identifiers: z.array(IdentifierSchema).nullish(), + pagination: PaginationResponseSchema.nullish(), + resolved_at: z.string().nullish(), + cache_valid_until: z.string().nullish(), + coverage_gaps: z.record(z.string(), z.array(IdentifierSchema)).nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListPropertyListsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + principal: z.string().nullish(), + name_contains: z.string().nullish(), + pagination: PaginationRequestSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListPropertyListsResponseSchema = z.object({ + lists: z.array(PropertyListSchema), + pagination: PaginationResponseSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const DeletePropertyListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish(), + idempotency_key: z.string().nullish() +}).passthrough(); + +export const DeletePropertyListResponseSchema = z.object({ + deleted: z.boolean(), + list_id: z.string(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CreateCollectionListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + name: z.string(), + description: z.string().nullish(), + base_collections: z.array(BaseCollectionSourceSchema).nullish(), + filters: CollectionListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CollectionListSchema = z.object({ + list_id: z.string(), + name: z.string(), + description: z.string().nullish(), + principal: z.string().nullish(), + base_collections: z.array(BaseCollectionSourceSchema).nullish(), + filters: CollectionListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + webhook_url: z.string().nullish(), + cache_duration_hours: z.number().nullish(), + created_at: z.string().nullish(), + updated_at: z.string().nullish(), + collection_count: z.number().nullish() +}).passthrough(); + +export const UpdateCollectionListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + name: z.string().nullish(), + description: z.string().nullish(), + base_collections: z.array(BaseCollectionSourceSchema).nullish(), + filters: CollectionListFiltersSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + webhook_url: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish(), + idempotency_key: z.string().nullish() +}).passthrough(); + +export const UpdateCollectionListResponseSchema = z.object({ + list: CollectionListSchema, + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetCollectionListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + resolve: z.boolean().nullish(), + pagination: z.object({ + max_results: z.number().nullish(), + cursor: z.string().nullish() + }).passthrough().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetCollectionListResponseSchema = z.object({ + list: CollectionListSchema, + collections: z.array(z.object({ + collection_rid: z.string().nullish(), + name: z.string(), + distribution_ids: z.array(z.object({ + type: DistributionIdentifierTypeSchema, + value: z.string() + }).passthrough()).nullish(), + content_rating: ContentRatingSchema.nullish(), + genre: z.array(z.string()).nullish(), + genre_taxonomy: GenreTaxonomySchema.nullish(), + kind: z.union([z.literal("series"), z.literal("publication"), z.literal("event_series"), z.literal("rotation")]).nullish() + }).passthrough()).nullish(), + pagination: PaginationResponseSchema.nullish(), + resolved_at: z.string().nullish(), + cache_valid_until: z.string().nullish(), + coverage_gaps: z.record(z.string(), z.array(z.object({ + type: DistributionIdentifierTypeSchema, + value: z.string() + }).passthrough())).nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListCollectionListsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + principal: z.string().nullish(), + name_contains: z.string().nullish(), + pagination: PaginationRequestSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListCollectionListsResponseSchema = z.object({ + lists: z.array(CollectionListSchema), + pagination: PaginationResponseSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const DeleteCollectionListRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + list_id: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish(), + idempotency_key: z.string().nullish() +}).passthrough(); + +export const DeleteCollectionListResponseSchema = z.object({ + deleted: z.boolean(), + list_id: z.string(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListContentStandardsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + channels: z.array(MediaChannelSchema).nullish(), + languages: z.array(z.string()).nullish(), + countries: z.array(z.string()).nullish(), + pagination: PaginationRequestSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ContentStandardsSchema = z.object({ + standards_id: z.string(), + name: z.string().nullish(), + countries_all: z.array(z.string()).nullish(), + channels_any: z.array(MediaChannelSchema).nullish(), + languages_any: z.array(z.string()).nullish(), + policy: z.string().nullish(), + calibration_exemplars: z.object({ + pass: z.array(ArtifactSchema).nullish(), + fail: z.array(ArtifactSchema).nullish() + }).passthrough().nullish(), + pricing_options: z.array(VendorPricingOptionSchema).nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetContentStandardsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + standards_id: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetContentStandardsResponseSchema = z.union([ContentStandardsSchema, z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const CreateContentStandardsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + scope: z.object({ + countries_all: z.array(z.string()).nullish(), + channels_any: z.array(MediaChannelSchema).nullish(), + languages_any: z.array(z.string()), + description: z.string().nullish() + }).passthrough(), + registry_policy_ids: z.array(z.string()).nullish(), + policy: z.string(), + calibration_exemplars: z.object({ + pass: z.array(z.union([z.object({ + type: z.literal("url"), + value: z.string(), + language: z.string().nullish() + }).passthrough(), ArtifactSchema])).nullish(), + fail: z.array(z.union([z.object({ + type: z.literal("url"), + value: z.string(), + language: z.string().nullish() + }).passthrough(), ArtifactSchema])).nullish() + }).passthrough().nullish(), + idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CreateContentStandardsResponseSchema = z.union([z.object({ + standards_id: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + conflicting_standards_id: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const UpdateContentStandardsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + standards_id: z.string(), + scope: z.object({ + countries_all: z.array(z.string()).nullish(), + channels_any: z.array(MediaChannelSchema).nullish(), + languages_any: z.array(z.string()).nullish(), + description: z.string().nullish() + }).passthrough().nullish(), + registry_policy_ids: z.array(z.string()).nullish(), + policy: z.string().nullish(), + calibration_exemplars: z.object({ + pass: z.array(z.union([z.object({ + type: z.literal("url"), + value: z.string(), + language: z.string().nullish() + }).passthrough(), ArtifactSchema])).nullish(), + fail: z.array(z.union([z.object({ + type: z.literal("url"), + value: z.string(), + language: z.string().nullish() + }).passthrough(), ArtifactSchema])).nullish() + }).passthrough().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish(), + idempotency_key: z.string().nullish() +}).passthrough(); + +export const UpdateContentStandardsSuccessSchema = z.object({ + success: z.literal(true), + standards_id: z.string(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const UpdateContentStandardsErrorSchema = z.object({ + success: z.literal(false), + errors: z.array(ErrorSchema), + conflicting_standards_id: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const CalibrateContentRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + standards_id: z.string(), + artifact: ArtifactSchema, + idempotency_key: z.string().nullish() +}).passthrough(); + +export const CalibrateContentResponseSchema = z.union([z.object({ + verdict: z.union([z.literal("pass"), z.literal("fail")]), + confidence: z.number().nullish(), + explanation: z.string().nullish(), + features: z.array(z.object({ + feature_id: z.string(), + status: z.union([z.literal("passed"), z.literal("failed"), z.literal("warning"), z.literal("unevaluated")]), + explanation: z.string().nullish() + }).passthrough()).nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const ValidateContentDeliveryRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + standards_id: z.string(), + records: z.array(z.object({ + record_id: z.string(), + media_buy_id: z.string().nullish(), + timestamp: z.string().nullish(), + artifact: ArtifactSchema, + country: z.string().nullish(), + channel: z.string().nullish(), + brand_context: z.object({ + brand_id: z.string().nullish(), + sku_id: z.string().nullish() + }).passthrough().nullish() + }).passthrough()), + feature_ids: z.array(z.string()).nullish(), + include_passed: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ValidateContentDeliveryResponseSchema = z.union([z.object({ + summary: z.object({ + total_records: z.number(), + passed_records: z.number(), + failed_records: z.number() + }).passthrough(), + results: z.array(z.object({ + record_id: z.string(), + verdict: z.union([z.literal("pass"), z.literal("fail")]), + features: z.array(z.object({ + feature_id: z.string(), + status: z.union([z.literal("passed"), z.literal("failed"), z.literal("warning"), z.literal("unevaluated")]), + value: z.unknown().nullish(), + message: z.string().nullish(), + rule_id: z.string().nullish() + }).passthrough()).nullish() + }).passthrough()), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const GetMediaBuyArtifactsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + account: AccountReferenceSchema.nullish(), + media_buy_id: z.string(), + package_ids: z.array(z.string()).nullish(), + failures_only: z.boolean().nullish(), + time_range: z.object({ + start: z.string().nullish(), + end: z.string().nullish() + }).passthrough().nullish(), + pagination: z.object({ + max_results: z.number().nullish(), + cursor: z.string().nullish() + }).passthrough().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetMediaBuyArtifactsResponseSchema = z.union([z.object({ + media_buy_id: z.string(), + artifacts: z.array(z.object({ + record_id: z.string(), + timestamp: z.string().nullish(), + package_id: z.string().nullish(), + artifact: ArtifactSchema, + country: z.string().nullish(), + channel: z.string().nullish(), + brand_context: z.object({ + brand_id: z.string().nullish(), + sku_id: z.string().nullish() + }).passthrough().nullish(), + local_verdict: z.union([z.literal("pass"), z.literal("fail"), z.literal("unevaluated")]).nullish() + }).passthrough()), + collection_info: z.object({ + total_deliveries: z.number().nullish(), + total_collected: z.number().nullish(), + returned_count: z.number().nullish(), + effective_rate: z.number().nullish() + }).passthrough().nullish(), + pagination: PaginationResponseSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const GetCreativeFeaturesRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + creative_manifest: CreativeManifestSchema, + feature_ids: z.array(z.string()).nullish(), + account: AccountReferenceSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetCreativeFeaturesResponseSchema = z.union([z.object({ + results: z.array(CreativeFeatureResultSchema), + detail_url: z.string().nullish(), + pricing_option_id: z.string().nullish(), + vendor_cost: z.number().nullish(), + currency: z.string().nullish(), + consumption: CreativeConsumptionSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const SyncPlansRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + plans: z.array(z.object({ + plan_id: z.string(), + brand: BrandReferenceSchema, + objectives: z.string(), + budget: z.object({ + total: z.number(), + currency: z.string(), + authority_level: BudgetAuthorityLevelSchema, + per_seller_max_pct: z.number().nullish(), + reallocation_threshold: z.number().nullish(), + allocations: z.record(z.string(), z.object({ + amount: z.number().nullish(), + max_pct: z.number().nullish() + }).passthrough()).nullish() + }).passthrough(), + channels: z.object({ + required: z.array(MediaChannelSchema).nullish(), + allowed: z.array(MediaChannelSchema).nullish(), + mix_targets: z.record(z.string(), z.object({ + min_pct: z.number().nullish(), + max_pct: z.number().nullish() + }).passthrough()).nullish() + }).passthrough().nullish(), + flight: z.object({ + start: z.string(), + end: z.string() + }).passthrough(), + countries: z.array(z.string()).nullish(), + regions: z.array(z.string()).nullish(), + policy_ids: z.array(z.string()).nullish(), + policy_categories: z.array(z.string()).nullish(), + audience: AudienceConstraintsSchema.nullish(), + restricted_attributes: z.array(RestrictedAttributeSchema).nullish(), + restricted_attributes_custom: z.array(z.string()).nullish(), + min_audience_size: z.number().nullish(), + custom_policies: z.array(z.string()).nullish(), + approved_sellers: z.array(z.string()).nullish().nullable(), + delegations: z.array(z.object({ + agent_url: z.string(), + authority: DelegationAuthoritySchema, + budget_limit: z.object({ + amount: z.number(), + currency: z.string() + }).passthrough().nullish(), + markets: z.array(z.string()).nullish(), + expires_at: z.string().nullish() + }).passthrough()).nullish(), + portfolio: z.object({ + member_plan_ids: z.array(z.string()), + total_budget_cap: z.object({ + amount: z.number(), + currency: z.string() + }).passthrough().nullish(), + shared_policy_ids: z.array(z.string()).nullish(), + shared_exclusions: z.array(z.string()).nullish() + }).passthrough().nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()) +}).passthrough(); + +export const SyncPlansResponseSchema = z.object({ + plans: z.array(z.object({ + plan_id: z.string(), + status: z.union([z.literal("active"), z.literal("error")]), + version: z.number(), + categories: z.array(z.object({ + category_id: z.string(), + status: z.union([z.literal("active"), z.literal("inactive")]) + }).passthrough()).nullish(), + resolved_policies: z.array(z.object({ + policy_id: z.string(), + source: z.union([z.literal("explicit"), z.literal("auto_applied")]), + enforcement: PolicyEnforcementLevelSchema, + reason: z.string().nullish() + }).passthrough()).nullish() + }).passthrough()) +}).passthrough(); + +export const ReportPlanOutcomeRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + plan_id: z.string(), + check_id: z.string().nullish(), + idempotency_key: z.string().nullish(), + purchase_type: PurchaseTypeSchema.nullish(), + outcome: OutcomeTypeSchema, + seller_response: z.object({ + seller_reference: z.string().nullish(), + committed_budget: z.number().nullish(), packages: z.array(z.object({ budget: z.number().nullish() }).passthrough()).nullish(), @@ -2937,8 +4350,6 @@ export const ReportPlanOutcomeRequestSchema = z.object({ governance_context: z.string() }).passthrough(); -export const EscalationSeveritySchema = z.union([z.literal("info"), z.literal("warning"), z.literal("critical")]); - export const ReportPlanOutcomeResponseSchema = z.object({ outcome_id: z.string(), status: z.union([z.literal("accepted"), z.literal("findings")]), @@ -3045,8 +4456,6 @@ export const GetPlanAuditLogsResponseSchema = z.object({ }).passthrough()) }).passthrough(); -export const GovernancePhaseSchema = z.union([z.literal("purchase"), z.literal("modification"), z.literal("delivery")]); - export const CheckGovernanceRequestSchema = z.object({ adcp_major_version: z.number().nullish(), plan_id: z.string(), @@ -3146,67 +4555,19 @@ export const SIGetOfferingResponseSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SIIdentitySchema = z.object({ - consent_granted: z.boolean(), - consent_timestamp: z.string().nullish(), - consent_scope: z.array(z.union([z.literal("name"), z.literal("email"), z.literal("shipping_address"), z.literal("phone"), z.literal("locale")])).nullish(), - privacy_policy_acknowledged: z.object({ - brand_policy_url: z.string().nullish(), - brand_policy_version: z.string().nullish() - }).passthrough().nullish(), - user: z.object({ - email: z.string().nullish(), - name: z.string().nullish(), - locale: z.string().nullish(), - phone: z.string().nullish(), - shipping_address: z.object({ - street: z.string().nullish(), - city: z.string().nullish(), - state: z.string().nullish(), - postal_code: z.string().nullish(), - country: z.string().nullish() - }).passthrough().nullish() - }).passthrough().nullish(), - anonymous_session_id: z.string().nullish() -}).passthrough(); - -export const SICapabilitiesSchema = z.object({ - modalities: z.object({ - conversational: z.boolean().nullish(), - voice: z.union([z.boolean(), z.object({ - provider: z.string().nullish(), - voice_id: z.string().nullish() - }).passthrough()]).nullish(), - video: z.union([z.boolean(), z.object({ - formats: z.array(z.string()).nullish(), - max_duration_seconds: z.number().nullish() - }).passthrough()]).nullish(), - avatar: z.union([z.boolean(), z.object({ - provider: z.string().nullish(), - avatar_id: z.string().nullish() - }).passthrough()]).nullish() - }).passthrough().nullish(), - components: z.object({ - standard: z.array(z.union([z.literal("text"), z.literal("link"), z.literal("image"), z.literal("product_card"), z.literal("carousel"), z.literal("action_button")])).nullish(), - extensions: z.object({}).passthrough().nullish() - }).passthrough().nullish(), - commerce: z.object({ - acp_checkout: z.boolean().nullish() - }).passthrough().nullish(), - a2ui: z.object({ - supported: z.boolean().nullish(), - catalogs: z.array(z.string()).nullish() - }).passthrough().nullish(), - mcp_apps: z.boolean().nullish() -}).passthrough(); - -export const SIUIElementSchema = z.object({ - type: z.union([z.literal("text"), z.literal("link"), z.literal("image"), z.literal("product_card"), z.literal("carousel"), z.literal("action_button"), z.literal("app_handoff"), z.literal("integration_actions")]), - data: z.object({}).passthrough().nullish() +export const SIInitiateSessionRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + context: z.string(), + identity: SIIdentitySchema, + media_buy_id: z.string().nullish(), + placement: z.string().nullish(), + offering_id: z.string().nullish(), + supported_capabilities: SICapabilitiesSchema.nullish(), + offering_token: z.string().nullish(), + idempotency_key: z.string().nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SISessionStatusSchema = z.union([z.literal("active"), z.literal("pending_handoff"), z.literal("complete"), z.literal("terminated")]); - export const SIInitiateSessionResponseSchema = z.object({ session_id: z.string(), response: z.object({ @@ -3231,10 +4592,32 @@ export const SISendMessageRequestSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const A2UIComponentSchema = z.object({ - id: z.string(), - parentId: z.string().nullish(), - component: z.record(z.string(), z.object({}).passthrough()) +export const SISendMessageResponseSchema = z.object({ + session_id: z.string(), + response: z.object({ + message: z.string().nullish(), + surface: A2UISurfaceSchema.nullish(), + ui_elements: z.array(SIUIElementSchema).nullish() + }).passthrough().nullish(), + mcp_resource_uri: z.string().nullish(), + session_status: SISessionStatusSchema, + handoff: z.object({ + type: z.union([z.literal("transaction"), z.literal("complete")]).nullish(), + intent: z.object({ + action: z.string().nullish(), + product: z.object({}).passthrough().nullish(), + price: z.object({ + amount: z.number().nullish(), + currency: z.string().nullish() + }).passthrough().nullish() + }).passthrough().nullish(), + context_for_checkout: z.object({ + conversation_summary: z.string().nullish(), + applied_offers: z.array(z.string()).nullish() + }).passthrough().nullish() + }).passthrough().nullish(), + errors: z.array(ErrorSchema).nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); export const SITerminateSessionRequestSchema = z.object({ @@ -3277,8 +4660,6 @@ export const GetAdCPCapabilitiesRequestSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const TransportModeSchema = z.union([z.literal("walking"), z.literal("cycling"), z.literal("driving"), z.literal("public_transport")]); - export const GetAdCPCapabilitiesResponseSchema = z.object({ adcp: z.object({ major_versions: z.array(z.number()) @@ -3505,1124 +4886,882 @@ export const SyncAccountsSuccessSchema = z.object({ }).passthrough().nullish(), errors: z.array(ErrorSchema).nullish(), warnings: z.array(z.string()).nullish(), - sandbox: z.boolean().nullish() - }).passthrough()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SyncAccountsErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SyncGovernanceRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - accounts: z.array(z.object({ - account: AccountReferenceSchema, - governance_agents: z.array(z.object({ - url: z.string(), - authentication: z.object({ - schemes: z.array(AuthenticationSchemeSchema), - credentials: z.string() - }).passthrough(), - categories: z.array(z.string()).nullish() - }).passthrough()) - }).passthrough()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SyncGovernanceSuccessSchema = z.object({ - accounts: z.array(z.object({ - account: AccountReferenceSchema, - status: z.union([z.literal("synced"), z.literal("failed")]), - governance_agents: z.array(z.object({ - url: z.string(), - categories: z.array(z.string()).nullish() - }).passthrough()).nullish(), - errors: z.array(ErrorSchema).nullish() - }).passthrough()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SyncGovernanceErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ReportUsageRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - idempotency_key: z.string().nullish(), - reporting_period: DatetimeRangeSchema, - usage: z.array(z.object({ - account: AccountReferenceSchema, - media_buy_id: z.string().nullish(), - vendor_cost: z.number(), - currency: z.string(), - pricing_option_id: z.string().nullish(), - impressions: z.number().nullish(), - media_spend: z.number().nullish(), - signal_agent_segment_id: z.string().nullish(), - standards_id: z.string().nullish(), - rights_id: z.string().nullish(), - creative_id: z.string().nullish(), - property_list_id: z.string().nullish() - }).passthrough()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ReportUsageResponseSchema = z.object({ - accepted: z.number(), - errors: z.array(ErrorSchema).nullish(), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const DateRangeSchema = z.object({ - start: z.string(), - end: z.string() -}).passthrough(); - -export const GetAccountFinancialsSuccessSchema = z.object({ - account: AccountReferenceSchema, - currency: z.string(), - period: DateRangeSchema, - timezone: z.string(), - spend: z.object({ - total_spend: z.number(), - media_buy_count: z.number().nullish() - }).passthrough().nullish(), - credit: z.object({ - credit_limit: z.number(), - available_credit: z.number(), - utilization_percent: z.number().nullish() - }).passthrough().nullish(), - balance: z.object({ - available: z.number(), - last_top_up: z.object({ - amount: z.number(), - date: z.string() - }).passthrough().nullish() - }).passthrough().nullish(), - payment_status: z.union([z.literal("current"), z.literal("past_due"), z.literal("suspended")]).nullish(), - payment_terms: z.union([z.literal("net_15"), z.literal("net_30"), z.literal("net_45"), z.literal("net_60"), z.literal("net_90"), z.literal("prepay")]).nullish(), - invoices: z.array(z.object({ - invoice_id: z.string(), - period: DateRangeSchema.nullish(), - amount: z.number(), - status: z.union([z.literal("draft"), z.literal("issued"), z.literal("paid"), z.literal("past_due"), z.literal("void")]), - due_date: z.string().nullish(), - paid_date: z.string().nullish() - }).passthrough()).nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const GetAccountFinancialsErrorSchema = z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ListScenariosSchema = z.object({ - scenario: z.literal("list_scenarios"), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ForceCreativeStatusSchema = z.object({ - scenario: z.literal("force_creative_status"), - params: z.object({ - creative_id: z.string(), - status: CreativeStatusSchema, - rejection_reason: z.string().nullish() - }).passthrough(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ForceAccountStatusSchema = z.object({ - scenario: z.literal("force_account_status"), - params: z.object({ - account_id: z.string(), - status: AccountStatusSchema - }).passthrough(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ForceMediaBuyStatusSchema = z.object({ - scenario: z.literal("force_media_buy_status"), - params: z.object({ - media_buy_id: z.string(), - status: MediaBuyStatusSchema, - rejection_reason: z.string().nullish() - }).passthrough(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ForceSessionStatusSchema = z.object({ - scenario: z.literal("force_session_status"), - params: z.object({ - session_id: z.string(), - status: z.union([z.literal("complete"), z.literal("terminated")]), - termination_reason: z.string().nullish() - }).passthrough(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SimulateDeliverySchema = z.object({ - scenario: z.literal("simulate_delivery"), - params: z.object({ - media_buy_id: z.string(), - impressions: z.number().nullish(), - clicks: z.number().nullish(), - reported_spend: z.object({ - amount: z.number(), - currency: z.string() - }).passthrough().nullish(), - conversions: z.number().nullish() - }).passthrough(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SimulateBudgetSpendSchema = z.object({ - scenario: z.literal("simulate_budget_spend"), - params: z.record(z.string(), z.unknown()), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ListScenariosSuccessSchema = z.object({ - success: z.literal(true), - scenarios: z.array(z.union([z.literal("force_creative_status"), z.literal("force_account_status"), z.literal("force_media_buy_status"), z.literal("force_session_status"), z.literal("simulate_delivery"), z.literal("simulate_budget_spend")])), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const StateTransitionSuccessSchema = z.object({ - success: z.literal(true), - previous_state: z.string(), - current_state: z.string(), - message: z.string().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SimulationSuccessSchema = z.object({ - success: z.literal(true), - simulated: z.object({}).passthrough(), - cumulative: z.object({}).passthrough().nullish(), - message: z.string().nullish(), + sandbox: z.boolean().nullish() + }).passthrough()), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ControllerErrorSchema = z.object({ - success: z.literal(false), - error: z.union([z.literal("INVALID_TRANSITION"), z.literal("INVALID_STATE"), z.literal("NOT_FOUND"), z.literal("UNKNOWN_SCENARIO"), z.literal("INVALID_PARAMS"), z.literal("FORBIDDEN"), z.literal("INTERNAL_ERROR")]), - error_detail: z.string().nullish(), - current_state: z.string().nullish().nullable(), +export const SyncAccountsErrorSchema = z.object({ + errors: z.array(ErrorSchema), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const MediaBuySchema = z.object({ - media_buy_id: z.string(), - account: AccountSchema.nullish(), - status: MediaBuyStatusSchema, - rejection_reason: z.string().nullish(), - confirmed_at: z.string().nullish(), - cancellation: z.object({ - canceled_at: z.string(), - canceled_by: CanceledBySchema, - reason: z.string().nullish() - }).passthrough().nullish(), - total_budget: z.number(), - packages: z.array(PackageSchema), - invoice_recipient: BusinessEntitySchema.nullish(), - creative_deadline: z.string().nullish(), - revision: z.number().nullish(), - created_at: z.string().nullish(), - updated_at: z.string().nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const InstallmentSchema = z.object({ - installment_id: z.string(), - collection_id: z.string().nullish(), - name: z.string().nullish(), - season: z.string().nullish(), - installment_number: z.string().nullish(), - scheduled_at: z.string().nullish(), - status: InstallmentStatusSchema.nullish(), - duration_seconds: z.number().nullish(), - flexible_end: z.boolean().nullish(), - valid_until: z.string().nullish(), - content_rating: ContentRatingSchema.nullish(), - topics: z.array(z.string()).nullish(), - special: SpecialSchema.nullish(), - guest_talent: z.array(TalentSchema).nullish(), - ad_inventory: AdInventoryConfigurationSchema.nullish(), - deadlines: InstallmentDeadlinesSchema.nullish(), - derivative_of: z.object({ - installment_id: z.string(), - type: DerivativeTypeSchema - }).passthrough().nullish(), +export const SyncGovernanceRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + accounts: z.array(z.object({ + account: AccountReferenceSchema, + governance_agents: z.array(z.object({ + url: z.string(), + authentication: z.object({ + schemes: z.array(AuthenticationSchemeSchema), + credentials: z.string() + }).passthrough(), + categories: z.array(z.string()).nullish() + }).passthrough()) + }).passthrough()), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const UpdateMediaBuyResponseSchema = z.union([UpdateMediaBuySuccessSchema, UpdateMediaBuyErrorSchema]); - -export const BuildCreativeResponseSchema = z.union([BuildCreativeSuccessSchema, BuildCreativeMultiSuccessSchema, BuildCreativeErrorSchema]); - -export const CreateMediaBuySuccessSchema = z.object({ - media_buy_id: z.string(), - account: AccountSchema.nullish(), - invoice_recipient: BusinessEntitySchema.nullish(), - status: MediaBuyStatusSchema.nullish(), - confirmed_at: z.string().nullish(), - creative_deadline: z.string().nullish(), - revision: z.number().nullish(), - valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), - packages: z.array(PackageSchema), - planned_delivery: PlannedDeliverySchema.nullish(), - sandbox: z.boolean().nullish(), +export const SyncGovernanceSuccessSchema = z.object({ + accounts: z.array(z.object({ + account: AccountReferenceSchema, + status: z.union([z.literal("synced"), z.literal("failed")]), + governance_agents: z.array(z.object({ + url: z.string(), + categories: z.array(z.string()).nullish() + }).passthrough()).nullish(), + errors: z.array(ErrorSchema).nullish() + }).passthrough()), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ProductSchema = z.object({ - product_id: z.string(), - name: z.string(), - description: z.string(), - publisher_properties: z.array(PublisherPropertySelectorSchema), - channels: z.array(MediaChannelSchema).nullish(), - format_ids: z.array(FormatIDSchema), - placements: z.array(PlacementSchema).nullish(), - delivery_type: DeliveryTypeSchema, - exclusivity: ExclusivitySchema.nullish(), - pricing_options: z.array(PricingOptionSchema), - forecast: DeliveryForecastSchema.nullish(), - outcome_measurement: OutcomeMeasurementSchema.nullish(), - delivery_measurement: z.object({ - provider: z.string(), - notes: z.string().nullish() - }).passthrough().nullish(), - measurement_terms: MeasurementTermsSchema.nullish(), - performance_standards: z.array(PerformanceStandardSchema).nullish(), - cancellation_policy: CancellationPolicySchema.nullish(), - reporting_capabilities: ReportingCapabilitiesSchema, - creative_policy: CreativePolicySchema.nullish(), - is_custom: z.boolean().nullish(), - property_targeting_allowed: z.boolean().nullish(), - data_provider_signals: z.array(DataProviderSignalSelectorSchema).nullish(), - signal_targeting_allowed: z.boolean().nullish(), - catalog_types: z.array(CatalogTypeSchema).nullish(), - metric_optimization: z.object({ - supported_metrics: z.array(z.union([z.literal("clicks"), z.literal("views"), z.literal("completed_views"), z.literal("viewed_seconds"), z.literal("attention_seconds"), z.literal("attention_score"), z.literal("engagements"), z.literal("follows"), z.literal("saves"), z.literal("profile_visits"), z.literal("reach")])), - supported_reach_units: z.array(ReachUnitSchema).nullish(), - supported_view_durations: z.array(z.number()).nullish(), - supported_targets: z.array(z.union([z.literal("cost_per"), z.literal("threshold_rate")])).nullish() - }).passthrough().nullish(), - max_optimization_goals: z.number().nullish(), - measurement_readiness: MeasurementReadinessSchema.nullish(), - conversion_tracking: z.object({ - action_sources: z.array(ActionSourceSchema).nullish(), - supported_targets: z.array(z.union([z.literal("cost_per"), z.literal("per_ad_spend"), z.literal("maximize_value")])).nullish(), - platform_managed: z.boolean().nullish() - }).passthrough().nullish(), - catalog_match: z.object({ - matched_gtins: z.array(z.string()).nullish(), - matched_ids: z.array(z.string()).nullish(), - matched_count: z.number().nullish(), - submitted_count: z.number() - }).passthrough().nullish(), - brief_relevance: z.string().nullish(), - expires_at: z.string().nullish(), - product_card: z.object({ - format_id: FormatIDSchema, - manifest: z.object({}).passthrough() - }).passthrough().nullish(), - product_card_detailed: z.object({ - format_id: FormatIDSchema, - manifest: z.object({}).passthrough() - }).passthrough().nullish(), - collections: z.array(CollectionSelectorSchema).nullish(), - collection_targeting_allowed: z.boolean().nullish(), - installments: z.array(InstallmentSchema).nullish(), - enforced_policies: z.array(z.string()).nullish(), - trusted_match: z.object({ - context_match: z.boolean(), - identity_match: z.boolean().nullish(), - response_types: z.array(TMPResponseTypeSchema).nullish(), - dynamic_brands: z.boolean().nullish(), - providers: z.array(z.object({ - agent_url: z.string(), - context_match: z.boolean().nullish(), - identity_match: z.boolean().nullish() - }).passthrough()).nullish() - }).passthrough().nullish(), - material_submission: z.object({ - url: z.string().nullish(), - email: z.string().nullish(), - instructions: z.string().nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough().nullish(), +export const SyncGovernanceErrorSchema = z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetProductsAsyncInputRequiredSchema = z.object({ - reason: z.union([z.literal("CLARIFICATION_NEEDED"), z.literal("BUDGET_REQUIRED")]).nullish(), - partial_results: z.array(ProductSchema).nullish(), - suggestions: z.array(z.string()).nullish(), +export const ReportUsageRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + idempotency_key: z.string().nullish(), + reporting_period: DatetimeRangeSchema, + usage: z.array(z.object({ + account: AccountReferenceSchema, + media_buy_id: z.string().nullish(), + vendor_cost: z.number(), + currency: z.string(), + pricing_option_id: z.string().nullish(), + impressions: z.number().nullish(), + media_spend: z.number().nullish(), + signal_agent_segment_id: z.string().nullish(), + standards_id: z.string().nullish(), + rights_id: z.string().nullish(), + creative_id: z.string().nullish(), + property_list_id: z.string().nullish() + }).passthrough()), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ProductFiltersSchema = z.object({ - delivery_type: DeliveryTypeSchema.nullish(), - exclusivity: ExclusivitySchema.nullish(), - is_fixed_price: z.boolean().nullish(), - format_ids: z.array(FormatIDSchema).nullish(), - standard_formats_only: z.boolean().nullish(), - min_exposures: z.number().nullish(), - start_date: z.string().nullish(), - end_date: z.string().nullish(), - budget_range: z.record(z.string(), z.unknown()).nullish(), - countries: z.array(z.string()).nullish(), - regions: z.array(z.string()).nullish(), - metros: z.array(z.object({ - system: MetroAreaSystemSchema, - code: z.string() - }).passthrough()).nullish(), - channels: z.array(MediaChannelSchema).nullish(), - required_axe_integrations: z.array(z.string()).nullish(), - trusted_match: z.object({ - providers: z.array(z.object({ - agent_url: z.string(), - context_match: z.boolean().nullish(), - identity_match: z.boolean().nullish() - }).passthrough()).nullish(), - response_types: z.array(TMPResponseTypeSchema).nullish() - }).passthrough().nullish(), - required_features: MediaBuyFeaturesSchema.nullish(), - required_geo_targeting: z.array(z.object({ - level: GeographicTargetingLevelSchema, - system: z.string().nullish() - }).passthrough()).nullish(), - signal_targeting: z.array(SignalTargetingSchema).nullish(), - postal_areas: z.array(z.object({ - system: PostalCodeSystemSchema, - values: z.array(z.string()) - }).passthrough()).nullish(), - geo_proximity: z.array(z.record(z.string(), z.unknown())).nullish(), - required_performance_standards: z.array(PerformanceStandardSchema).nullish(), - keywords: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]).nullish() - }).passthrough()).nullish() -}).passthrough(); - -export const GetProductsResponseSchema = z.object({ - products: z.array(ProductSchema), - proposals: z.array(ProposalSchema).nullish(), +export const ReportUsageResponseSchema = z.object({ + accepted: z.number(), errors: z.array(ErrorSchema).nullish(), - property_list_applied: z.boolean().nullish(), - catalog_applied: z.boolean().nullish(), - refinement_applied: z.array(z.object({ - scope: z.union([z.literal("request"), z.literal("product"), z.literal("proposal")]).nullish(), - id: z.string().nullish(), - status: z.union([z.literal("applied"), z.literal("partial"), z.literal("unable")]), - notes: z.string().nullish() - }).passthrough()).nullish(), - incomplete: z.array(z.object({ - scope: z.union([z.literal("products"), z.literal("pricing"), z.literal("forecast"), z.literal("proposals")]), - description: z.string(), - estimated_wait: DurationSchema.nullish() - }).passthrough()).nullish(), - pagination: PaginationResponseSchema.nullish(), sandbox: z.boolean().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const VendorPricingSchema = z.union([CpmPricingSchema, PercentOfMediaPricingSchema, FlatFeePricingSchema, PerUnitPricingSchema]); - -export const BaseIndividualAssetSchema = z.object({ - item_type: z.literal("individual"), - asset_id: z.string(), - asset_role: z.string().nullish(), - required: z.boolean(), - overlays: z.array(OverlaySchema).nullish() -}).passthrough(); - -export const VendorPricingOptionSchema = z.object({ - pricing_option_id: z.string() -}).passthrough().and(VendorPricingSchema); - -export const PackageRequestSchema = z.object({ +export const GetAccountFinancialsRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - product_id: z.string(), - format_ids: z.array(FormatIDSchema).nullish(), - budget: z.number(), - pacing: PacingSchema.nullish(), - pricing_option_id: z.string(), - bid_price: z.number().nullish(), - impressions: z.number().nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - paused: z.boolean().nullish(), - catalogs: z.array(CatalogSchema).nullish(), - optimization_goals: z.array(OptimizationGoalSchema).nullish(), - targeting_overlay: TargetingOverlaySchema.nullish(), - measurement_terms: MeasurementTermsSchema.nullish(), - performance_standards: z.array(PerformanceStandardSchema).nullish(), - creative_assignments: z.array(CreativeAssignmentSchema).nullish(), - creatives: z.array(CreativeAssetSchema).nullish(), - agency_estimate_number: z.string().nullish(), + account: AccountReferenceSchema, + period: DateRangeSchema.nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreateMediaBuyResponseSchema = z.union([CreateMediaBuySuccessSchema, CreateMediaBuyErrorSchema]); - -export const PackageUpdateSchema = z.object({ - package_id: z.string(), - budget: z.number().nullish(), - pacing: PacingSchema.nullish(), - bid_price: z.number().nullish(), - impressions: z.number().nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - paused: z.boolean().nullish(), - canceled: z.literal(true).nullish(), - cancellation_reason: z.string().nullish(), - catalogs: z.array(CatalogSchema).nullish(), - optimization_goals: z.array(OptimizationGoalSchema).nullish(), - targeting_overlay: TargetingOverlaySchema.nullish(), - keyword_targets_add: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]), - bid_price: z.number().nullish() - }).passthrough()).nullish(), - keyword_targets_remove: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) - }).passthrough()).nullish(), - negative_keywords_add: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) - }).passthrough()).nullish(), - negative_keywords_remove: z.array(z.object({ - keyword: z.string(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) +export const GetAccountFinancialsSuccessSchema = z.object({ + account: AccountReferenceSchema, + currency: z.string(), + period: DateRangeSchema, + timezone: z.string(), + spend: z.object({ + total_spend: z.number(), + media_buy_count: z.number().nullish() + }).passthrough().nullish(), + credit: z.object({ + credit_limit: z.number(), + available_credit: z.number(), + utilization_percent: z.number().nullish() + }).passthrough().nullish(), + balance: z.object({ + available: z.number(), + last_top_up: z.object({ + amount: z.number(), + date: z.string() + }).passthrough().nullish() + }).passthrough().nullish(), + payment_status: z.union([z.literal("current"), z.literal("past_due"), z.literal("suspended")]).nullish(), + payment_terms: z.union([z.literal("net_15"), z.literal("net_30"), z.literal("net_45"), z.literal("net_60"), z.literal("net_90"), z.literal("prepay")]).nullish(), + invoices: z.array(z.object({ + invoice_id: z.string(), + period: DateRangeSchema.nullish(), + amount: z.number(), + status: z.union([z.literal("draft"), z.literal("issued"), z.literal("paid"), z.literal("past_due"), z.literal("void")]), + due_date: z.string().nullish(), + paid_date: z.string().nullish() }).passthrough()).nullish(), - creative_assignments: z.array(CreativeAssignmentSchema).nullish(), - creatives: z.array(CreativeAssetSchema).nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetMediaBuysResponseSchema = z.object({ - media_buys: z.array(z.object({ - media_buy_id: z.string(), - account: AccountSchema.nullish(), - invoice_recipient: BusinessEntitySchema.nullish(), - status: MediaBuyStatusSchema, - currency: z.string(), - total_budget: z.number().nullish(), - start_time: z.string().nullish(), - end_time: z.string().nullish(), - creative_deadline: z.string().nullish(), - confirmed_at: z.string().nullish(), - cancellation: z.object({ - canceled_at: z.string(), - canceled_by: CanceledBySchema, - reason: z.string().nullish() - }).passthrough().nullish(), - revision: z.number().nullish(), - created_at: z.string().nullish(), - updated_at: z.string().nullish(), - valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), - history: z.array(z.object({ - revision: z.number(), - timestamp: z.string(), - actor: z.string().nullish(), - action: z.string(), - summary: z.string().nullish(), - package_id: z.string().nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()).nullish(), - packages: z.array(PackageStatusSchema), - ext: ExtensionObjectSchema.nullish() - }).passthrough()), - errors: z.array(ErrorSchema).nullish(), - pagination: PaginationResponseSchema.nullish(), - sandbox: z.boolean().nullish(), +export const GetAccountFinancialsErrorSchema = z.object({ + errors: z.array(ErrorSchema), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetMediaBuyDeliveryResponseSchema = z.object({ - notification_type: z.union([z.literal("scheduled"), z.literal("final"), z.literal("delayed"), z.literal("adjusted"), z.literal("window_update")]).nullish(), - partial_data: z.boolean().nullish(), - unavailable_count: z.number().nullish(), - sequence_number: z.number().nullish(), - next_expected_at: z.string().nullish(), - reporting_period: z.object({ - start: z.string(), - end: z.string() - }).passthrough(), - currency: z.string().nullish(), - attribution_window: AttributionWindowSchema.nullish(), - aggregated_totals: z.object({ - impressions: z.number(), - spend: z.number(), - clicks: z.number().nullish(), - completed_views: z.number().nullish(), - views: z.number().nullish(), - conversions: z.number().nullish(), - conversion_value: z.number().nullish(), - roas: z.number().nullish(), - new_to_brand_rate: z.number().nullish(), - cost_per_acquisition: z.number().nullish(), - completion_rate: z.number().nullish(), - reach: z.number().nullish(), - reach_unit: ReachUnitSchema.nullish(), - frequency: z.number().nullish(), - media_buy_count: z.number() - }).passthrough().nullish(), - media_buy_deliveries: z.array(z.object({ - media_buy_id: z.string(), - status: z.union([z.literal("pending_creatives"), z.literal("pending_start"), z.literal("pending"), z.literal("active"), z.literal("paused"), z.literal("completed"), z.literal("rejected"), z.literal("canceled"), z.literal("failed"), z.literal("reporting_delayed")]), - expected_availability: z.string().nullish(), - is_adjusted: z.boolean().nullish(), - pricing_model: PricingModelSchema.nullish(), - totals: DeliveryMetricsSchema.and(z.object({ - effective_rate: z.number().nullish() - }).passthrough()), - by_package: z.array(DeliveryMetricsSchema.and(z.object({ - package_id: z.string(), - pacing_index: z.number().nullish(), - pricing_model: PricingModelSchema.nullish(), - rate: z.number().nullish(), - currency: z.string().nullish(), - delivery_status: z.union([z.literal("delivering"), z.literal("completed"), z.literal("budget_exhausted"), z.literal("flight_ended"), z.literal("goal_met")]).nullish(), - paused: z.boolean().nullish(), - is_final: z.boolean().nullish(), - measurement_window: z.string().nullish(), - supersedes_window: z.string().nullish(), - by_catalog_item: z.array(DeliveryMetricsSchema.and(z.object({ - content_id: z.string().nullish(), - content_id_type: ContentIDTypeSchema.nullish() - }).passthrough())).nullish(), - by_creative: z.array(DeliveryMetricsSchema.and(z.object({ - creative_id: z.string(), - weight: z.number().nullish() - }).passthrough())).nullish(), - by_keyword: z.array(DeliveryMetricsSchema.and(z.object({ - keyword: z.string().nullish(), - match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]).nullish() - }).passthrough())).nullish(), - by_geo: z.array(DeliveryMetricsSchema.and(z.object({ - geo_level: GeographicTargetingLevelSchema.nullish(), - system: z.string().nullish(), - geo_code: z.string().nullish(), - geo_name: z.string().nullish() - }).passthrough())).nullish(), - by_geo_truncated: z.boolean().nullish(), - by_device_type: z.array(DeliveryMetricsSchema.and(z.object({ - device_type: DeviceTypeSchema.nullish() - }).passthrough())).nullish(), - by_device_type_truncated: z.boolean().nullish(), - by_device_platform: z.array(DeliveryMetricsSchema.and(z.object({ - device_platform: DevicePlatformSchema.nullish() - }).passthrough())).nullish(), - by_device_platform_truncated: z.boolean().nullish(), - by_audience: z.array(DeliveryMetricsSchema.and(z.object({ - audience_id: z.string().nullish(), - audience_source: AudienceSourceSchema.nullish(), - audience_name: z.string().nullish() - }).passthrough())).nullish(), - by_audience_truncated: z.boolean().nullish(), - by_placement: z.array(DeliveryMetricsSchema.and(z.object({ - placement_id: z.string().nullish(), - placement_name: z.string().nullish() - }).passthrough())).nullish(), - by_placement_truncated: z.boolean().nullish(), - daily_breakdown: z.array(z.object({ - date: z.string(), - impressions: z.number(), - spend: z.number(), - conversions: z.number().nullish(), - conversion_value: z.number().nullish(), - roas: z.number().nullish(), - new_to_brand_rate: z.number().nullish() - }).passthrough()).nullish() - }).passthrough())), - daily_breakdown: z.array(z.object({ - date: z.string(), - impressions: z.number(), - spend: z.number(), - conversions: z.number().nullish(), - conversion_value: z.number().nullish(), - roas: z.number().nullish(), - new_to_brand_rate: z.number().nullish() - }).passthrough()).nullish() - }).passthrough()), - errors: z.array(ErrorSchema).nullish(), - sandbox: z.boolean().nullish(), +export const ListScenariosSchema = z.object({ + scenario: z.literal("list_scenarios"), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ForceCreativeStatusSchema = z.object({ + scenario: z.literal("force_creative_status"), + params: z.object({ + creative_id: z.string(), + status: CreativeStatusSchema, + rejection_reason: z.string().nullish() + }).passthrough(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ProvidePerformanceFeedbackRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - media_buy_id: z.string(), - idempotency_key: z.string().nullish(), - measurement_period: DatetimeRangeSchema, - performance_index: z.number(), - package_id: z.string().nullish(), - creative_id: z.string().nullish(), - metric_type: MetricTypeSchema.nullish(), - feedback_source: FeedbackSourceSchema.nullish(), +export const ForceAccountStatusSchema = z.object({ + scenario: z.literal("force_account_status"), + params: z.object({ + account_id: z.string(), + status: AccountStatusSchema + }).passthrough(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ProvidePerformanceFeedbackResponseSchema = z.union([ProvidePerformanceFeedbackSuccessSchema, ProvidePerformanceFeedbackErrorSchema]); +export const ForceMediaBuyStatusSchema = z.object({ + scenario: z.literal("force_media_buy_status"), + params: z.object({ + media_buy_id: z.string(), + status: MediaBuyStatusSchema, + rejection_reason: z.string().nullish() + }).passthrough(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const SyncEventSourcesSuccessSchema = z.object({ - event_sources: z.array(z.object({ - event_source_id: z.string(), - name: z.string().nullish(), - seller_id: z.string().nullish(), - event_types: z.array(EventTypeSchema).nullish(), - action_source: ActionSourceSchema.nullish(), - managed_by: z.union([z.literal("buyer"), z.literal("seller")]).nullish(), - setup: z.object({ - snippet: z.string().nullish(), - snippet_type: z.union([z.literal("javascript"), z.literal("html"), z.literal("pixel_url"), z.literal("server_only")]).nullish(), - instructions: z.string().nullish() +export const ForceSessionStatusSchema = z.object({ + scenario: z.literal("force_session_status"), + params: z.object({ + session_id: z.string(), + status: z.union([z.literal("complete"), z.literal("terminated")]), + termination_reason: z.string().nullish() + }).passthrough(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const SimulateDeliverySchema = z.object({ + scenario: z.literal("simulate_delivery"), + params: z.object({ + media_buy_id: z.string(), + impressions: z.number().nullish(), + clicks: z.number().nullish(), + reported_spend: z.object({ + amount: z.number(), + currency: z.string() }).passthrough().nullish(), - action: z.union([z.literal("created"), z.literal("updated"), z.literal("unchanged"), z.literal("deleted"), z.literal("failed")]), - health: EventSourceHealthSchema.nullish(), - errors: z.array(ErrorSchema).nullish() - }).passthrough()), + conversions: z.number().nullish() + }).passthrough(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const SimulateBudgetSpendSchema = z.object({ + scenario: z.literal("simulate_budget_spend"), + params: z.record(z.string(), z.unknown()), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ListScenariosSuccessSchema = z.object({ + success: z.literal(true), + scenarios: z.array(z.union([z.literal("force_creative_status"), z.literal("force_account_status"), z.literal("force_media_buy_status"), z.literal("force_session_status"), z.literal("simulate_delivery"), z.literal("simulate_budget_spend")])), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const StateTransitionSuccessSchema = z.object({ + success: z.literal(true), + previous_state: z.string(), + current_state: z.string(), + message: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const SimulationSuccessSchema = z.object({ + success: z.literal(true), + simulated: z.object({}).passthrough(), + cumulative: z.object({}).passthrough().nullish(), + message: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const ControllerErrorSchema = z.object({ + success: z.literal(false), + error: z.union([z.literal("INVALID_TRANSITION"), z.literal("INVALID_STATE"), z.literal("NOT_FOUND"), z.literal("UNKNOWN_SCENARIO"), z.literal("INVALID_PARAMS"), z.literal("FORBIDDEN"), z.literal("INTERNAL_ERROR")]), + error_detail: z.string().nullish(), + current_state: z.string().nullish().nullable(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const MediaBuySchema = z.object({ + media_buy_id: z.string(), + account: AccountSchema.nullish(), + status: MediaBuyStatusSchema, + rejection_reason: z.string().nullish(), + confirmed_at: z.string().nullish(), + cancellation: z.object({ + canceled_at: z.string(), + canceled_by: CanceledBySchema, + reason: z.string().nullish() + }).passthrough().nullish(), + total_budget: z.number(), + packages: z.array(PackageSchema), + invoice_recipient: BusinessEntitySchema.nullish(), + creative_deadline: z.string().nullish(), + revision: z.number().nullish(), + created_at: z.string().nullish(), + updated_at: z.string().nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const InstallmentSchema = z.object({ + installment_id: z.string(), + collection_id: z.string().nullish(), + name: z.string().nullish(), + season: z.string().nullish(), + installment_number: z.string().nullish(), + scheduled_at: z.string().nullish(), + status: InstallmentStatusSchema.nullish(), + duration_seconds: z.number().nullish(), + flexible_end: z.boolean().nullish(), + valid_until: z.string().nullish(), + content_rating: ContentRatingSchema.nullish(), + topics: z.array(z.string()).nullish(), + special: SpecialSchema.nullish(), + guest_talent: z.array(TalentSchema).nullish(), + ad_inventory: AdInventoryConfigurationSchema.nullish(), + deadlines: InstallmentDeadlinesSchema.nullish(), + derivative_of: z.object({ + installment_id: z.string(), + type: DerivativeTypeSchema + }).passthrough().nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const UpdateMediaBuyResponseSchema = z.union([UpdateMediaBuySuccessSchema, UpdateMediaBuyErrorSchema]); + +export const BuildCreativeResponseSchema = z.union([BuildCreativeSuccessSchema, BuildCreativeMultiSuccessSchema, BuildCreativeErrorSchema]); + +export const CreateMediaBuySuccessSchema = z.object({ + media_buy_id: z.string(), + account: AccountSchema.nullish(), + invoice_recipient: BusinessEntitySchema.nullish(), + status: MediaBuyStatusSchema.nullish(), + confirmed_at: z.string().nullish(), + creative_deadline: z.string().nullish(), + revision: z.number().nullish(), + valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), + packages: z.array(PackageSchema), + planned_delivery: PlannedDeliverySchema.nullish(), sandbox: z.boolean().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const EventSchema = z.object({ - event_id: z.string(), - event_type: EventTypeSchema, - event_time: z.string(), - user_match: UserMatchSchema.nullish(), - custom_data: EventCustomDataSchema.nullish(), - action_source: ActionSourceSchema.nullish(), - event_source_url: z.string().nullish(), - custom_event_name: z.string().nullish(), +export const ProductSchema = z.object({ + product_id: z.string(), + name: z.string(), + description: z.string(), + publisher_properties: z.array(PublisherPropertySelectorSchema), + channels: z.array(MediaChannelSchema).nullish(), + format_ids: z.array(FormatIDSchema), + placements: z.array(PlacementSchema).nullish(), + delivery_type: DeliveryTypeSchema, + exclusivity: ExclusivitySchema.nullish(), + pricing_options: z.array(PricingOptionSchema), + forecast: DeliveryForecastSchema.nullish(), + outcome_measurement: OutcomeMeasurementSchema.nullish(), + delivery_measurement: z.object({ + provider: z.string(), + notes: z.string().nullish() + }).passthrough().nullish(), + measurement_terms: MeasurementTermsSchema.nullish(), + performance_standards: z.array(PerformanceStandardSchema).nullish(), + cancellation_policy: CancellationPolicySchema.nullish(), + reporting_capabilities: ReportingCapabilitiesSchema, + creative_policy: CreativePolicySchema.nullish(), + is_custom: z.boolean().nullish(), + property_targeting_allowed: z.boolean().nullish(), + data_provider_signals: z.array(DataProviderSignalSelectorSchema).nullish(), + signal_targeting_allowed: z.boolean().nullish(), + catalog_types: z.array(CatalogTypeSchema).nullish(), + metric_optimization: z.object({ + supported_metrics: z.array(z.union([z.literal("clicks"), z.literal("views"), z.literal("completed_views"), z.literal("viewed_seconds"), z.literal("attention_seconds"), z.literal("attention_score"), z.literal("engagements"), z.literal("follows"), z.literal("saves"), z.literal("profile_visits"), z.literal("reach")])), + supported_reach_units: z.array(ReachUnitSchema).nullish(), + supported_view_durations: z.array(z.number()).nullish(), + supported_targets: z.array(z.union([z.literal("cost_per"), z.literal("threshold_rate")])).nullish() + }).passthrough().nullish(), + max_optimization_goals: z.number().nullish(), + measurement_readiness: MeasurementReadinessSchema.nullish(), + conversion_tracking: z.object({ + action_sources: z.array(ActionSourceSchema).nullish(), + supported_targets: z.array(z.union([z.literal("cost_per"), z.literal("per_ad_spend"), z.literal("maximize_value")])).nullish(), + platform_managed: z.boolean().nullish() + }).passthrough().nullish(), + catalog_match: z.object({ + matched_gtins: z.array(z.string()).nullish(), + matched_ids: z.array(z.string()).nullish(), + matched_count: z.number().nullish(), + submitted_count: z.number() + }).passthrough().nullish(), + brief_relevance: z.string().nullish(), + expires_at: z.string().nullish(), + product_card: z.object({ + format_id: FormatIDSchema, + manifest: z.object({}).passthrough() + }).passthrough().nullish(), + product_card_detailed: z.object({ + format_id: FormatIDSchema, + manifest: z.object({}).passthrough() + }).passthrough().nullish(), + collections: z.array(CollectionSelectorSchema).nullish(), + collection_targeting_allowed: z.boolean().nullish(), + installments: z.array(InstallmentSchema).nullish(), + enforced_policies: z.array(z.string()).nullish(), + trusted_match: z.object({ + context_match: z.boolean(), + identity_match: z.boolean().nullish(), + response_types: z.array(TMPResponseTypeSchema).nullish(), + dynamic_brands: z.boolean().nullish(), + providers: z.array(z.object({ + agent_url: z.string(), + context_match: z.boolean().nullish(), + identity_match: z.boolean().nullish() + }).passthrough()).nullish() + }).passthrough().nullish(), + material_submission: z.object({ + url: z.string().nullish(), + email: z.string().nullish(), + instructions: z.string().nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const LogEventResponseSchema = z.union([LogEventSuccessSchema, LogEventErrorSchema]); - -export const SyncAudiencesResponseSchema = z.union([SyncAudiencesSuccessSchema, SyncAudiencesErrorSchema]); - -export const BuildCreativeRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - message: z.string().nullish(), - creative_manifest: CreativeManifestSchema.nullish(), - creative_id: z.string().nullish(), - concept_id: z.string().nullish(), - media_buy_id: z.string().nullish(), - package_id: z.string().nullish(), - target_format_id: FormatIDSchema.nullish(), - target_format_ids: z.array(FormatIDSchema).nullish(), - account: AccountReferenceSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - quality: CreativeQualitySchema.nullish(), - item_limit: z.number().nullish(), - include_preview: z.boolean().nullish(), - preview_inputs: z.array(z.object({ - name: z.string(), - macros: z.record(z.string(), z.string()).nullish(), - context_description: z.string().nullish() - }).passthrough()).nullish(), - preview_quality: CreativeQualitySchema.nullish(), - preview_output_format: PreviewOutputFormatSchema.nullish(), - macro_values: z.record(z.string(), z.string()).nullish(), - idempotency_key: z.string().nullish(), +export const GetProductsAsyncInputRequiredSchema = z.object({ + reason: z.union([z.literal("CLARIFICATION_NEEDED"), z.literal("BUDGET_REQUIRED")]).nullish(), + partial_results: z.array(ProductSchema).nullish(), + suggestions: z.array(z.string()).nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PreviewCreativeBatchResponseSchema = z.object({ - response_type: z.literal("batch"), - results: z.array(z.union([PreviewBatchResultSuccessSchema, PreviewBatchResultErrorSchema])), +export const AcquireRightsRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + rights_id: z.string(), + pricing_option_id: z.string(), + buyer: BrandReferenceSchema, + campaign: z.object({ + description: z.string(), + uses: z.array(RightUseSchema), + countries: z.array(z.string()).nullish(), + format_ids: z.array(FormatIDSchema).nullish(), + estimated_impressions: z.number().nullish(), + start_date: z.string().nullish(), + end_date: z.string().nullish() + }).passthrough(), + revocation_webhook: PushNotificationConfigSchema, + push_notification_config: PushNotificationConfigSchema.nullish(), + idempotency_key: z.string().nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetCreativeDeliveryResponseSchema = z.object({ - account_id: z.string().nullish(), - media_buy_id: z.string().nullish(), - currency: z.string(), - reporting_period: z.object({ - start: z.string(), - end: z.string(), - timezone: z.string().nullish() - }).passthrough(), - creatives: z.array(z.object({ - creative_id: z.string(), - media_buy_id: z.string().nullish(), - format_id: FormatIDSchema.nullish(), - totals: DeliveryMetricsSchema.nullish(), - variant_count: z.number().nullish(), - variants: z.array(CreativeVariantSchema) - }).passthrough()), - pagination: z.object({ - limit: z.number(), - offset: z.number(), - has_more: z.boolean(), - total: z.number().nullish() +export const AcquireRightsAcquiredSchema = z.object({ + rights_id: z.string(), + status: z.literal("acquired"), + brand_id: z.string(), + terms: RightsTermsSchema, + generation_credentials: z.array(GenerationCredentialSchema), + restrictions: z.array(z.string()).nullish(), + disclosure: z.object({ + required: z.boolean(), + text: z.string().nullish() }).passthrough().nullish(), - errors: z.array(ErrorSchema).nullish(), + approval_webhook: PushNotificationConfigSchema.nullish(), + usage_reporting_url: z.string().nullish(), + rights_constraint: RightsConstraintSchema, context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListCreativesRequestSchema = z.object({ +export const GetBrandIdentityResponseSchema = z.union([GetBrandIdentitySuccessSchema, GetBrandIdentityErrorSchema]); + +export const GetRightsRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - filters: CreativeFiltersSchema.nullish(), - sort: z.object({ - field: CreativeSortFieldSchema.nullish(), - direction: SortDirectionSchema.nullish() - }).passthrough().nullish(), + query: z.string(), + uses: z.array(RightUseSchema), + buyer_brand: BrandReferenceSchema.nullish(), + countries: z.array(z.string()).nullish(), + brand_id: z.string().nullish(), + right_type: RightTypeSchema.nullish(), + include_excluded: z.boolean().nullish(), pagination: PaginationRequestSchema.nullish(), - include_assignments: z.boolean().nullish(), - include_snapshot: z.boolean().nullish(), - include_items: z.boolean().nullish(), - include_variables: z.boolean().nullish(), - include_pricing: z.boolean().nullish(), - account: AccountReferenceSchema.nullish(), - fields: z.array(z.union([z.literal("creative_id"), z.literal("name"), z.literal("format_id"), z.literal("status"), z.literal("created_date"), z.literal("updated_date"), z.literal("tags"), z.literal("assignments"), z.literal("snapshot"), z.literal("items"), z.literal("variables"), z.literal("concept"), z.literal("pricing_options")])).nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListCreativesResponseSchema = z.object({ - query_summary: z.object({ - total_matching: z.number(), - returned: z.number(), - filters_applied: z.array(z.string()).nullish(), - sort_applied: z.object({ - field: z.string().nullish(), - direction: SortDirectionSchema.nullish() - }).passthrough().nullish() - }).passthrough(), - pagination: PaginationResponseSchema, - creatives: z.array(z.object({ - creative_id: z.string(), - account: AccountSchema.nullish(), +export const GetRightsSuccessSchema = z.object({ + rights: z.array(z.object({ + rights_id: z.string(), + brand_id: z.string(), name: z.string(), - format_id: FormatIDSchema, - status: CreativeStatusSchema, - created_date: z.string(), - updated_date: z.string(), - assets: z.record(z.string(), z.union([ImageAssetSchema, VideoAssetSchema, AudioAssetSchema, VASTAssetSchema, TextAssetSchema, URLAssetSchema, HTMLAssetSchema, JavaScriptAssetSchema, WebhookAssetSchema, CSSAssetSchema, DAASTAssetSchema, MarkdownAssetSchema, BriefAssetSchema, CatalogAssetSchema])).nullish(), - tags: z.array(z.string()).nullish(), - concept_id: z.string().nullish(), - concept_name: z.string().nullish(), - variables: z.array(CreativeVariableSchema).nullish(), - assignments: z.object({ - assignment_count: z.number(), - assigned_packages: z.array(z.object({ - package_id: z.string(), - assigned_date: z.string() - }).passthrough()).nullish() - }).passthrough().nullish(), - snapshot: z.object({ - as_of: z.string(), - staleness_seconds: z.number(), - impressions: z.number(), - last_served: z.string().nullish() + description: z.string().nullish(), + right_type: RightTypeSchema.nullish(), + match_score: z.number().nullish(), + match_reasons: z.array(z.string()).nullish(), + available_uses: z.array(RightUseSchema), + countries: z.array(z.string()).nullish(), + excluded_countries: z.array(z.string()).nullish(), + exclusivity_status: z.object({ + available: z.boolean().nullish(), + existing_exclusives: z.array(z.string()).nullish() }).passthrough().nullish(), - snapshot_unavailable_reason: z.union([z.literal("SNAPSHOT_UNSUPPORTED"), z.literal("SNAPSHOT_TEMPORARILY_UNAVAILABLE"), z.literal("SNAPSHOT_PERMISSION_DENIED")]).nullish(), - items: z.array(CreativeItemSchema).nullish(), - pricing_options: z.array(VendorPricingOptionSchema).nullish() + pricing_options: z.array(RightsPricingOptionSchema), + content_restrictions: z.array(z.string()).nullish(), + preview_assets: z.array(z.object({ + url: z.string(), + usage: z.string().nullish() + }).passthrough()).nullish() }).passthrough()), - format_summary: z.record(z.string(), z.number()).nullish(), - status_summary: z.object({ - processing: z.number().nullish(), - approved: z.number().nullish(), - pending_review: z.number().nullish(), - rejected: z.number().nullish(), - archived: z.number().nullish() - }).passthrough().nullish(), - errors: z.array(ErrorSchema).nullish(), - sandbox: z.boolean().nullish(), + excluded: z.array(z.object({ + brand_id: z.string(), + name: z.string().nullish(), + reason: z.string(), + suggestions: z.array(z.string()).nullish() + }).passthrough()).nullish(), context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetSignalsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema.nullish(), - signal_spec: z.string().nullish(), - signal_ids: z.array(SignalIDSchema).nullish(), - destinations: z.array(DestinationSchema).nullish(), - countries: z.array(z.string()).nullish(), - filters: SignalFiltersSchema.nullish(), - max_results: z.number().nullish(), - pagination: PaginationRequestSchema.nullish(), - context: ContextObjectSchema.nullish(), +export const ArtifactWebhookPayloadSchema = z.object({ + media_buy_id: z.string(), + batch_id: z.string(), + timestamp: z.string(), + artifacts: z.array(z.object({ + artifact: ArtifactSchema, + delivered_at: z.string(), + impression_id: z.string().nullish(), + package_id: z.string().nullish() + }).passthrough()), + pagination: z.object({ + total_artifacts: z.number().nullish(), + batch_number: z.number().nullish(), + total_batches: z.number().nullish() + }).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetSignalsResponseSchema = z.object({ - signals: z.array(z.object({ - signal_id: SignalIDSchema.nullish(), - signal_agent_segment_id: z.string(), - name: z.string(), - description: z.string(), - value_type: SignalValueTypeSchema.nullish(), - categories: z.array(z.string()).nullish(), - range: z.object({ - min: z.number(), - max: z.number() - }).passthrough().nullish(), - signal_type: SignalCatalogTypeSchema, - data_provider: z.string(), - coverage_percentage: z.number(), - deployments: z.array(DeploymentSchema), - pricing_options: z.array(VendorPricingOptionSchema) - }).passthrough()), - errors: z.array(ErrorSchema).nullish(), - pagination: PaginationResponseSchema.nullish(), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), +export const CollectionSchema = z.object({ + collection_id: z.string(), + name: z.string(), + kind: z.union([z.literal("series"), z.literal("publication"), z.literal("event_series"), z.literal("rotation")]).nullish(), + description: z.string().nullish(), + genre: z.array(z.string()).nullish(), + genre_taxonomy: z.string().nullish(), + language: z.string().nullish(), + content_rating: ContentRatingSchema.nullish(), + cadence: CollectionCadenceSchema.nullish(), + season: z.string().nullish(), + status: CollectionStatusSchema.nullish(), + production_quality: ProductionQualitySchema.nullish(), + talent: z.array(TalentSchema).nullish(), + special: SpecialSchema.nullish(), + limited_series: LimitedSeriesSchema.nullish(), + distribution: z.array(CollectionDistributionSchema).nullish(), + deadline_policy: DeadlinePolicySchema.nullish(), + related_collections: z.array(z.object({ + collection_id: z.string(), + relationship: CollectionRelationshipSchema + }).passthrough()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ActivateSignalResponseSchema = z.union([ActivateSignalSuccessSchema, ActivateSignalErrorSchema]); - -export const CreatePropertyListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), +export const DestinationItemSchema = z.object({ + destination_id: z.string(), name: z.string(), description: z.string().nullish(), - base_properties: z.array(BasePropertySourceSchema).nullish(), - filters: PropertyListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - idempotency_key: z.string().nullish(), - context: ContextObjectSchema.nullish(), + city: z.string().nullish(), + region: z.string().nullish(), + country: z.string().nullish(), + location: z.object({ + lat: z.number(), + lng: z.number() + }).passthrough().nullish(), + destination_type: z.union([z.literal("beach"), z.literal("mountain"), z.literal("urban"), z.literal("cultural"), z.literal("adventure"), z.literal("wellness"), z.literal("cruise")]).nullish(), + price: PriceSchema.nullish(), + image_url: z.string().nullish(), + url: z.string().nullish(), + rating: z.number().nullish(), + tags: z.array(z.string()).nullish(), + assets: z.array(OfferingAssetGroupSchema).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const PropertyListSchema = z.object({ - list_id: z.string(), +export const FormatSchema = z.object({ + format_id: FormatIDSchema, name: z.string(), description: z.string().nullish(), - principal: z.string().nullish(), - base_properties: z.array(BasePropertySourceSchema).nullish(), - filters: PropertyListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - webhook_url: z.string().nullish(), - cache_duration_hours: z.number().nullish(), - created_at: z.string().nullish(), - updated_at: z.string().nullish(), - property_count: z.number().nullish(), + example_url: z.string().nullish(), + accepts_parameters: z.array(FormatIDParameterSchema).nullish(), + renders: z.array(z.union([z.record(z.string(), z.unknown()), z.object({ + parameters_from_format_id: z.literal(true) + }).passthrough()])).nullish(), + assets: z.array(z.union([BaseIndividualAssetSchema, z.object({ + item_type: z.literal("repeatable_group"), + asset_group_id: z.string(), + required: z.boolean(), + min_count: z.number(), + max_count: z.number(), + selection_mode: z.union([z.literal("sequential"), z.literal("optimize")]).nullish(), + assets: z.array(BaseGroupAssetSchema) + }).passthrough()])).nullish(), + delivery: z.object({}).passthrough().nullish(), + supported_macros: z.array(z.union([UniversalMacroSchema, z.string()])).nullish(), + input_format_ids: z.array(FormatIDSchema).nullish(), + output_format_ids: z.array(FormatIDSchema).nullish(), + format_card: z.object({ + format_id: FormatIDSchema, + manifest: z.object({}).passthrough() + }).passthrough().nullish(), + accessibility: z.object({ + wcag_level: WCAGLevelSchema, + requires_accessible_assets: z.boolean().nullish() + }).passthrough().nullish(), + supported_disclosure_positions: z.array(DisclosurePositionSchema).nullish(), + disclosure_capabilities: z.array(z.object({ + position: DisclosurePositionSchema, + persistence: z.array(DisclosurePersistenceSchema) + }).passthrough()).nullish(), + format_card_detailed: z.object({ + format_id: FormatIDSchema, + manifest: z.object({}).passthrough() + }).passthrough().nullish(), + reported_metrics: z.array(AvailableMetricSchema).nullish(), pricing_options: z.array(VendorPricingOptionSchema).nullish() }).passthrough(); -export const UpdatePropertyListResponseSchema = z.object({ - list: PropertyListSchema, - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const GetPropertyListResponseSchema = z.object({ - list: PropertyListSchema, - identifiers: z.array(IdentifierSchema).nullish(), - pagination: PaginationResponseSchema.nullish(), - resolved_at: z.string().nullish(), - cache_valid_until: z.string().nullish(), - coverage_gaps: z.record(z.string(), z.array(IdentifierSchema)).nullish(), +export const OfferingAssetConstraintSchema = z.object({ + asset_group_id: z.string(), + asset_type: AssetContentTypeSchema, + required: z.boolean().nullish(), + min_count: z.number().nullish(), + max_count: z.number().nullish(), + asset_requirements: AssetRequirementsSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ListPropertyListsResponseSchema = z.object({ - lists: z.array(PropertyListSchema), - pagination: PaginationResponseSchema.nullish(), +export const SignalPricingOptionSchema = z.object({ + pricing_option_id: z.string() +}).passthrough().and(VendorPricingSchema); + +export const StoreItemSchema = z.object({ + store_id: z.string(), + name: z.string(), + location: z.object({ + lat: z.number(), + lng: z.number() + }).passthrough(), + address: z.object({ + street: z.string().nullish(), + city: z.string().nullish(), + region: z.string().nullish(), + postal_code: z.string().nullish(), + country: z.string().nullish() + }).passthrough().nullish(), + catchments: z.array(CatchmentSchema).nullish(), + phone: z.string().nullish(), + url: z.string().nullish(), + hours: z.record(z.string(), z.string()).nullish(), + tags: z.array(z.string()).nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreateCollectionListRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), +export const PolicyEntrySchema = z.object({ + policy_id: z.string(), + version: z.string(), name: z.string(), description: z.string().nullish(), - base_collections: z.array(BaseCollectionSourceSchema).nullish(), - filters: CollectionListFiltersSchema.nullish(), - brand: BrandReferenceSchema.nullish(), - idempotency_key: z.string().nullish(), - context: ContextObjectSchema.nullish(), + category: PolicyCategorySchema, + enforcement: PolicyEnforcementLevelSchema, + jurisdictions: z.array(z.string()).nullish(), + region_aliases: z.record(z.string(), z.array(z.string())).nullish(), + policy_categories: z.array(z.string()).nullish(), + channels: z.array(MediaChannelSchema).nullish(), + governance_domains: z.array(GovernanceDomainSchema).nullish(), + effective_date: z.string().nullish(), + sunset_date: z.string().nullish(), + source_url: z.string().nullish(), + source_name: z.string().nullish(), + policy: z.string(), + guidance: z.string().nullish(), + exemplars: z.object({ + pass: z.array(ExemplarSchema).nullish(), + fail: z.array(ExemplarSchema).nullish() + }).passthrough().nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const CreateCollectionListResponseSchema = z.object({ - list: CollectionListSchema, - auth_token: z.string(), +export const PackageUpdateSchema = z.object({ + package_id: z.string(), + budget: z.number().nullish(), + pacing: PacingSchema.nullish(), + bid_price: z.number().nullish(), + impressions: z.number().nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + paused: z.boolean().nullish(), + canceled: z.literal(true).nullish(), + cancellation_reason: z.string().nullish(), + catalogs: z.array(CatalogSchema).nullish(), + optimization_goals: z.array(OptimizationGoalSchema).nullish(), + targeting_overlay: TargetingOverlaySchema.nullish(), + keyword_targets_add: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]), + bid_price: z.number().nullish() + }).passthrough()).nullish(), + keyword_targets_remove: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) + }).passthrough()).nullish(), + negative_keywords_add: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) + }).passthrough()).nullish(), + negative_keywords_remove: z.array(z.object({ + keyword: z.string(), + match_type: z.union([z.literal("broad"), z.literal("phrase"), z.literal("exact")]) + }).passthrough()).nullish(), + creative_assignments: z.array(CreativeAssignmentSchema).nullish(), + creatives: z.array(CreativeAssetSchema).nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const UpdateCollectionListResponseSchema = z.object({ - list: CollectionListSchema, +export const GetProductsResponseSchema = z.object({ + products: z.array(ProductSchema), + proposals: z.array(ProposalSchema).nullish(), + errors: z.array(ErrorSchema).nullish(), + property_list_applied: z.boolean().nullish(), + catalog_applied: z.boolean().nullish(), + refinement_applied: z.array(z.object({ + scope: z.union([z.literal("request"), z.literal("product"), z.literal("proposal")]).nullish(), + id: z.string().nullish(), + status: z.union([z.literal("applied"), z.literal("partial"), z.literal("unable")]), + notes: z.string().nullish() + }).passthrough()).nullish(), + incomplete: z.array(z.object({ + scope: z.union([z.literal("products"), z.literal("pricing"), z.literal("forecast"), z.literal("proposals")]), + description: z.string(), + estimated_wait: DurationSchema.nullish() + }).passthrough()).nullish(), + pagination: PaginationResponseSchema.nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const ContentStandardsSchema = z.object({ - standards_id: z.string(), - name: z.string().nullish(), - countries_all: z.array(z.string()).nullish(), - channels_any: z.array(MediaChannelSchema).nullish(), - languages_any: z.array(z.string()).nullish(), - policy: z.string().nullish(), - calibration_exemplars: z.object({ - pass: z.array(ArtifactSchema).nullish(), - fail: z.array(ArtifactSchema).nullish() - }).passthrough().nullish(), - pricing_options: z.array(VendorPricingOptionSchema).nullish(), +export const ListCreativeFormatsResponseSchema = z.object({ + formats: z.array(FormatSchema), + creative_agents: z.array(z.object({ + agent_url: z.string(), + agent_name: z.string().nullish(), + capabilities: z.array(CreativeAgentCapabilitySchema).nullish() + }).passthrough()).nullish(), + errors: z.array(ErrorSchema).nullish(), + pagination: PaginationResponseSchema.nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const GetContentStandardsResponseSchema = z.union([ContentStandardsSchema, z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const UpdateContentStandardsResponseSchema = z.union([UpdateContentStandardsSuccessSchema, UpdateContentStandardsErrorSchema]); +export const PackageRequestSchema = z.object({ + adcp_major_version: z.number().nullish(), + product_id: z.string(), + format_ids: z.array(FormatIDSchema).nullish(), + budget: z.number(), + pacing: PacingSchema.nullish(), + pricing_option_id: z.string(), + bid_price: z.number().nullish(), + impressions: z.number().nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + paused: z.boolean().nullish(), + catalogs: z.array(CatalogSchema).nullish(), + optimization_goals: z.array(OptimizationGoalSchema).nullish(), + targeting_overlay: TargetingOverlaySchema.nullish(), + measurement_terms: MeasurementTermsSchema.nullish(), + performance_standards: z.array(PerformanceStandardSchema).nullish(), + creative_assignments: z.array(CreativeAssignmentSchema).nullish(), + creatives: z.array(CreativeAssetSchema).nullish(), + agency_estimate_number: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const GetCreativeFeaturesResponseSchema = z.union([z.object({ - results: z.array(CreativeFeatureResultSchema), - detail_url: z.string().nullish(), - pricing_option_id: z.string().nullish(), - vendor_cost: z.number().nullish(), - currency: z.string().nullish(), - consumption: CreativeConsumptionSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); +export const CreateMediaBuyResponseSchema = z.union([CreateMediaBuySuccessSchema, CreateMediaBuyErrorSchema]); -export const SyncPlansRequestSchema = z.object({ +export const UpdateMediaBuyRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - plans: z.array(z.object({ - plan_id: z.string(), - brand: BrandReferenceSchema, - objectives: z.string(), - budget: z.object({ - total: z.number(), - currency: z.string(), - authority_level: BudgetAuthorityLevelSchema, - per_seller_max_pct: z.number().nullish(), - reallocation_threshold: z.number().nullish(), - allocations: z.record(z.string(), z.object({ - amount: z.number().nullish(), - max_pct: z.number().nullish() - }).passthrough()).nullish() - }).passthrough(), - channels: z.object({ - required: z.array(MediaChannelSchema).nullish(), - allowed: z.array(MediaChannelSchema).nullish(), - mix_targets: z.record(z.string(), z.object({ - min_pct: z.number().nullish(), - max_pct: z.number().nullish() - }).passthrough()).nullish() - }).passthrough().nullish(), - flight: z.object({ - start: z.string(), - end: z.string() - }).passthrough(), - countries: z.array(z.string()).nullish(), - regions: z.array(z.string()).nullish(), - policy_ids: z.array(z.string()).nullish(), - policy_categories: z.array(z.string()).nullish(), - audience: AudienceConstraintsSchema.nullish(), - restricted_attributes: z.array(RestrictedAttributeSchema).nullish(), - restricted_attributes_custom: z.array(z.string()).nullish(), - min_audience_size: z.number().nullish(), - custom_policies: z.array(z.string()).nullish(), - approved_sellers: z.array(z.string()).nullish().nullable(), - delegations: z.array(z.object({ - agent_url: z.string(), - authority: DelegationAuthoritySchema, - budget_limit: z.object({ - amount: z.number(), - currency: z.string() - }).passthrough().nullish(), - markets: z.array(z.string()).nullish(), - expires_at: z.string().nullish() - }).passthrough()).nullish(), - portfolio: z.object({ - member_plan_ids: z.array(z.string()), - total_budget_cap: z.object({ - amount: z.number(), - currency: z.string() - }).passthrough().nullish(), - shared_policy_ids: z.array(z.string()).nullish(), - shared_exclusions: z.array(z.string()).nullish() + media_buy_id: z.string(), + revision: z.number().nullish(), + paused: z.boolean().nullish(), + canceled: z.literal(true).nullish(), + cancellation_reason: z.string().nullish(), + start_time: StartTimingSchema.nullish(), + end_time: z.string().nullish(), + packages: z.array(PackageUpdateSchema).nullish(), + invoice_recipient: BusinessEntitySchema.nullish(), + new_packages: z.array(PackageRequestSchema).nullish(), + reporting_webhook: ReportingWebhookSchema.nullish(), + push_notification_config: PushNotificationConfigSchema.nullish(), + idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); + +export const GetMediaBuysResponseSchema = z.object({ + media_buys: z.array(z.object({ + media_buy_id: z.string(), + account: AccountSchema.nullish(), + invoice_recipient: BusinessEntitySchema.nullish(), + status: MediaBuyStatusSchema, + currency: z.string(), + total_budget: z.number().nullish(), + start_time: z.string().nullish(), + end_time: z.string().nullish(), + creative_deadline: z.string().nullish(), + confirmed_at: z.string().nullish(), + cancellation: z.object({ + canceled_at: z.string(), + canceled_by: CanceledBySchema, + reason: z.string().nullish() }).passthrough().nullish(), + revision: z.number().nullish(), + created_at: z.string().nullish(), + updated_at: z.string().nullish(), + valid_actions: z.array(z.union([z.literal("pause"), z.literal("resume"), z.literal("cancel"), z.literal("update_budget"), z.literal("update_dates"), z.literal("update_packages"), z.literal("add_packages"), z.literal("sync_creatives")])).nullish(), + history: z.array(z.object({ + revision: z.number(), + timestamp: z.string(), + actor: z.string().nullish(), + action: z.string(), + summary: z.string().nullish(), + package_id: z.string().nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()).nullish(), + packages: z.array(PackageStatusSchema), ext: ExtensionObjectSchema.nullish() - }).passthrough()) + }).passthrough()), + errors: z.array(ErrorSchema).nullish(), + pagination: PaginationResponseSchema.nullish(), + sandbox: z.boolean().nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SIInitiateSessionRequestSchema = z.object({ +export const ProvidePerformanceFeedbackResponseSchema = z.union([ProvidePerformanceFeedbackSuccessSchema, ProvidePerformanceFeedbackErrorSchema]); + +export const SyncEventSourcesResponseSchema = z.union([SyncEventSourcesSuccessSchema, SyncEventSourcesErrorSchema]); + +export const LogEventResponseSchema = z.union([LogEventSuccessSchema, LogEventErrorSchema]); + +export const SyncAudiencesResponseSchema = z.union([SyncAudiencesSuccessSchema, SyncAudiencesErrorSchema]); + +export const BuildCreativeRequestSchema = z.object({ adcp_major_version: z.number().nullish(), - context: z.string(), - identity: SIIdentitySchema, + message: z.string().nullish(), + creative_manifest: CreativeManifestSchema.nullish(), + creative_id: z.string().nullish(), + concept_id: z.string().nullish(), media_buy_id: z.string().nullish(), - placement: z.string().nullish(), - offering_id: z.string().nullish(), - supported_capabilities: SICapabilitiesSchema.nullish(), - offering_token: z.string().nullish(), + package_id: z.string().nullish(), + target_format_id: FormatIDSchema.nullish(), + target_format_ids: z.array(FormatIDSchema).nullish(), + account: AccountReferenceSchema.nullish(), + brand: BrandReferenceSchema.nullish(), + quality: CreativeQualitySchema.nullish(), + item_limit: z.number().nullish(), + include_preview: z.boolean().nullish(), + preview_inputs: z.array(z.object({ + name: z.string(), + macros: z.record(z.string(), z.string()).nullish(), + context_description: z.string().nullish() + }).passthrough()).nullish(), + preview_quality: CreativeQualitySchema.nullish(), + preview_output_format: PreviewOutputFormatSchema.nullish(), + macro_values: z.record(z.string(), z.string()).nullish(), idempotency_key: z.string().nullish(), + context: ContextObjectSchema.nullish(), ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const A2UISurfaceSchema = z.object({ - surfaceId: z.string(), - catalogId: z.string().nullish(), - components: z.array(A2UIComponentSchema), - rootId: z.string().nullish(), - dataModel: z.object({}).passthrough().nullish() +export const PreviewCreativeBatchResponseSchema = z.object({ + response_type: z.literal("batch"), + results: z.array(z.union([PreviewBatchResultSuccessSchema, PreviewBatchResultErrorSchema])), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const SyncAccountsResponseSchema = z.union([SyncAccountsSuccessSchema, SyncAccountsErrorSchema]); +export const ActivateSignalResponseSchema = z.union([ActivateSignalSuccessSchema, ActivateSignalErrorSchema]); -export const SyncGovernanceResponseSchema = z.union([SyncGovernanceSuccessSchema, SyncGovernanceErrorSchema]); +export const CreatePropertyListResponseSchema = z.object({ + list: PropertyListSchema, + auth_token: z.string(), + ext: ExtensionObjectSchema.nullish() +}).passthrough(); -export const GetAccountFinancialsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - account: AccountReferenceSchema, - period: DateRangeSchema.nullish(), - context: ContextObjectSchema.nullish(), +export const CreateCollectionListResponseSchema = z.object({ + list: CollectionListSchema, + auth_token: z.string(), ext: ExtensionObjectSchema.nullish() }).passthrough(); +export const ListContentStandardsResponseSchema = z.union([z.object({ + standards: z.array(ContentStandardsSchema), + pagination: PaginationResponseSchema.nullish(), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough(), z.object({ + errors: z.array(ErrorSchema), + context: ContextObjectSchema.nullish(), + ext: ExtensionObjectSchema.nullish() + }).passthrough()]); + +export const UpdateContentStandardsResponseSchema = z.union([UpdateContentStandardsSuccessSchema, UpdateContentStandardsErrorSchema]); + +export const SyncAccountsResponseSchema = z.union([SyncAccountsSuccessSchema, SyncAccountsErrorSchema]); + +export const SyncGovernanceResponseSchema = z.union([SyncGovernanceSuccessSchema, SyncGovernanceErrorSchema]); + export const GetAccountFinancialsResponseSchema = z.union([GetAccountFinancialsSuccessSchema, GetAccountFinancialsErrorSchema]); export const ComplyTestControllerRequestSchema = z.union([ListScenariosSchema, ForceCreativeStatusSchema, ForceAccountStatusSchema, ForceMediaBuyStatusSchema, ForceSessionStatusSchema, SimulateDeliverySchema, SimulateBudgetSpendSchema]); @@ -4643,79 +5782,19 @@ export const MCPWebhookPayloadSchema: z.ZodType = z.object({ result: AdCPAsyncResponseDataSchema.nullish() }).passthrough(); -export const GetProductsRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - buying_mode: z.union([z.literal("brief"), z.literal("wholesale"), z.literal("refine")]), - brief: z.string().nullish(), - refine: z.array(z.union([z.object({ - scope: z.literal("request"), - ask: z.string() - }).passthrough(), z.object({ - scope: z.literal("product"), - id: z.string(), - action: z.union([z.literal("include"), z.literal("omit"), z.literal("more_like_this")]), - ask: z.string().nullish() - }).passthrough(), z.object({ - scope: z.literal("proposal"), - id: z.string(), - action: z.union([z.literal("include"), z.literal("omit"), z.literal("finalize")]), - ask: z.string().nullish() - }).passthrough()])).nullish(), - brand: BrandReferenceSchema.nullish(), - catalog: CatalogSchema.nullish(), - account: AccountReferenceSchema.nullish(), - preferred_delivery_types: z.array(DeliveryTypeSchema).nullish(), - filters: ProductFiltersSchema.nullish(), - property_list: PropertyListReferenceSchema.nullish(), - fields: z.array(z.union([z.literal("product_id"), z.literal("name"), z.literal("description"), z.literal("publisher_properties"), z.literal("channels"), z.literal("format_ids"), z.literal("placements"), z.literal("delivery_type"), z.literal("exclusivity"), z.literal("pricing_options"), z.literal("forecast"), z.literal("outcome_measurement"), z.literal("delivery_measurement"), z.literal("reporting_capabilities"), z.literal("creative_policy"), z.literal("catalog_types"), z.literal("metric_optimization"), z.literal("conversion_tracking"), z.literal("data_provider_signals"), z.literal("max_optimization_goals"), z.literal("catalog_match"), z.literal("collections"), z.literal("collection_targeting_allowed"), z.literal("installments"), z.literal("brief_relevance"), z.literal("expires_at"), z.literal("product_card"), z.literal("product_card_detailed"), z.literal("enforced_policies"), z.literal("trusted_match")])).nullish(), - time_budget: DurationSchema.nullish(), - pagination: PaginationRequestSchema.nullish(), - context: ContextObjectSchema.nullish(), - required_policies: z.array(z.string()).nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); +export const AcquireRightsResponseSchema = z.union([AcquireRightsAcquiredSchema, AcquireRightsPendingApprovalSchema, AcquireRightsRejectedSchema, AcquireRightsErrorSchema]); -export const FormatSchema = z.object({ - format_id: FormatIDSchema, - name: z.string(), - description: z.string().nullish(), - example_url: z.string().nullish(), - accepts_parameters: z.array(FormatIDParameterSchema).nullish(), - renders: z.array(z.union([z.record(z.string(), z.unknown()), z.object({ - parameters_from_format_id: z.literal(true) - }).passthrough()])).nullish(), - assets: z.array(z.union([BaseIndividualAssetSchema, z.object({ - item_type: z.literal("repeatable_group"), - asset_group_id: z.string(), - required: z.boolean(), - min_count: z.number(), - max_count: z.number(), - selection_mode: z.union([z.literal("sequential"), z.literal("optimize")]).nullish(), - assets: z.array(BaseGroupAssetSchema) - }).passthrough()])).nullish(), - delivery: z.object({}).passthrough().nullish(), - supported_macros: z.array(z.union([UniversalMacroSchema, z.string()])).nullish(), - input_format_ids: z.array(FormatIDSchema).nullish(), - output_format_ids: z.array(FormatIDSchema).nullish(), - format_card: z.object({ - format_id: FormatIDSchema, - manifest: z.object({}).passthrough() - }).passthrough().nullish(), - accessibility: z.object({ - wcag_level: WCAGLevelSchema, - requires_accessible_assets: z.boolean().nullish() - }).passthrough().nullish(), - supported_disclosure_positions: z.array(DisclosurePositionSchema).nullish(), - disclosure_capabilities: z.array(z.object({ - position: DisclosurePositionSchema, - persistence: z.array(DisclosurePersistenceSchema) - }).passthrough()).nullish(), - format_card_detailed: z.object({ - format_id: FormatIDSchema, - manifest: z.object({}).passthrough() - }).passthrough().nullish(), - reported_metrics: z.array(AvailableMetricSchema).nullish(), - pricing_options: z.array(VendorPricingOptionSchema).nullish() +export const GetRightsResponseSchema = z.union([GetRightsSuccessSchema, GetRightsErrorSchema]); + +export const CatalogRequirementsSchema = z.object({ + catalog_type: CatalogTypeSchema, + required: z.boolean().nullish(), + min_items: z.number().nullish(), + max_items: z.number().nullish(), + required_fields: z.array(z.string()).nullish(), + feed_formats: z.array(FeedFormatSchema).nullish(), + offering_asset_constraints: z.array(OfferingAssetConstraintSchema).nullish(), + field_bindings: z.array(CatalogFieldBindingSchema).nullish() }).passthrough(); export const CreateMediaBuyRequestSchema = z.object({ @@ -4759,94 +5838,4 @@ export const CreateMediaBuyRequestSchema = z.object({ ext: ExtensionObjectSchema.nullish() }).passthrough(); -export const UpdateMediaBuyRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - media_buy_id: z.string(), - revision: z.number().nullish(), - paused: z.boolean().nullish(), - canceled: z.literal(true).nullish(), - cancellation_reason: z.string().nullish(), - start_time: StartTimingSchema.nullish(), - end_time: z.string().nullish(), - packages: z.array(PackageUpdateSchema).nullish(), - invoice_recipient: BusinessEntitySchema.nullish(), - new_packages: z.array(PackageRequestSchema).nullish(), - reporting_webhook: ReportingWebhookSchema.nullish(), - push_notification_config: PushNotificationConfigSchema.nullish(), - idempotency_key: z.string().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const SyncEventSourcesResponseSchema = z.union([SyncEventSourcesSuccessSchema, SyncEventSourcesErrorSchema]); - -export const LogEventRequestSchema = z.object({ - adcp_major_version: z.number().nullish(), - event_source_id: z.string(), - test_event_code: z.string().nullish(), - events: z.array(EventSchema), - idempotency_key: z.string().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - export const PreviewCreativeResponseSchema = z.union([PreviewCreativeSingleResponseSchema, PreviewCreativeBatchResponseSchema, PreviewCreativeVariantResponseSchema]); - -export const CreatePropertyListResponseSchema = z.object({ - list: PropertyListSchema, - auth_token: z.string(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ListContentStandardsResponseSchema = z.union([z.object({ - standards: z.array(ContentStandardsSchema), - pagination: PaginationResponseSchema.nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough(), z.object({ - errors: z.array(ErrorSchema), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() - }).passthrough()]); - -export const SISendMessageResponseSchema = z.object({ - session_id: z.string(), - response: z.object({ - message: z.string().nullish(), - surface: A2UISurfaceSchema.nullish(), - ui_elements: z.array(SIUIElementSchema).nullish() - }).passthrough().nullish(), - mcp_resource_uri: z.string().nullish(), - session_status: SISessionStatusSchema, - handoff: z.object({ - type: z.union([z.literal("transaction"), z.literal("complete")]).nullish(), - intent: z.object({ - action: z.string().nullish(), - product: z.object({}).passthrough().nullish(), - price: z.object({ - amount: z.number().nullish(), - currency: z.string().nullish() - }).passthrough().nullish() - }).passthrough().nullish(), - context_for_checkout: z.object({ - conversation_summary: z.string().nullish(), - applied_offers: z.array(z.string()).nullish() - }).passthrough().nullish() - }).passthrough().nullish(), - errors: z.array(ErrorSchema).nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); - -export const ListCreativeFormatsResponseSchema = z.object({ - formats: z.array(FormatSchema), - creative_agents: z.array(z.object({ - agent_url: z.string(), - agent_name: z.string().nullish(), - capabilities: z.array(CreativeAgentCapabilitySchema).nullish() - }).passthrough()).nullish(), - errors: z.array(ErrorSchema).nullish(), - pagination: PaginationResponseSchema.nullish(), - sandbox: z.boolean().nullish(), - context: ContextObjectSchema.nullish(), - ext: ExtensionObjectSchema.nullish() -}).passthrough(); diff --git a/src/lib/utils/response-schemas.ts b/src/lib/utils/response-schemas.ts index b6c3256f..e723e4ae 100644 --- a/src/lib/utils/response-schemas.ts +++ b/src/lib/utils/response-schemas.ts @@ -59,6 +59,13 @@ export const TOOL_RESPONSE_SCHEMAS: Partial> = { calibrate_content: schemas.CalibrateContentResponseSchema, validate_content_delivery: schemas.ValidateContentDeliveryResponseSchema, + // Collection lists + create_collection_list: schemas.CreateCollectionListResponseSchema, + update_collection_list: schemas.UpdateCollectionListResponseSchema, + get_collection_list: schemas.GetCollectionListResponseSchema, + list_collection_lists: schemas.ListCollectionListsResponseSchema, + delete_collection_list: schemas.DeleteCollectionListResponseSchema, + // Campaign governance sync_plans: schemas.SyncPlansResponseSchema, check_governance: schemas.CheckGovernanceResponseSchema, @@ -84,21 +91,12 @@ export const TOOL_RESPONSE_SCHEMAS: Partial> = { z.object({ errors: z.array(schemas.ErrorSchema) }).passthrough(), ]), - // Brand rights — no generated schemas yet, hand-written from protocol spec. - // Replace with generated schemas once the schema generator covers brand tools. - // .passthrough() preserves extra fields from agent responses (e.g., generation_credentials). - get_brand_identity: z.union([ - z.object({ brand_id: z.string(), names: z.array(z.unknown()) }).passthrough(), - z.object({ errors: z.array(schemas.ErrorSchema) }).passthrough(), - ]), - get_rights: z.union([ - z.object({ rights: z.array(z.object({ rights_id: z.string() }).passthrough()) }).passthrough(), - z.object({ errors: z.array(schemas.ErrorSchema) }).passthrough(), - ]), - acquire_rights: z.union([ - z.object({ rights_id: z.string(), status: z.string() }).passthrough(), - z.object({ errors: z.array(schemas.ErrorSchema) }).passthrough(), - ]), + // Brand rights + get_brand_identity: schemas.GetBrandIdentityResponseSchema, + get_rights: schemas.GetRightsResponseSchema, + acquire_rights: schemas.AcquireRightsResponseSchema, + + // Brand rights — no schema definitions yet for these tools update_rights: z.union([ z.object({ rights_id: z.string() }).passthrough(), z.object({ errors: z.array(schemas.ErrorSchema) }).passthrough(), diff --git a/src/lib/utils/tool-request-schemas.ts b/src/lib/utils/tool-request-schemas.ts new file mode 100644 index 00000000..94063519 --- /dev/null +++ b/src/lib/utils/tool-request-schemas.ts @@ -0,0 +1,95 @@ +/** + * Canonical map of AdCP tool names to their Zod request schemas. + * + * Use with MCP SDK's server.tool() for type-safe tool registration: + * + * import { TOOL_REQUEST_SCHEMAS } from '@adcp/client'; + * server.tool('get_products', TOOL_REQUEST_SCHEMAS.get_products.shape, handler); + */ + +import { z } from 'zod'; +import * as schemas from '../types/schemas.generated'; + +export const TOOL_REQUEST_SCHEMAS: Partial> = { + // Product discovery & media buy + get_products: schemas.GetProductsRequestSchema, + create_media_buy: schemas.CreateMediaBuyRequestSchema, + update_media_buy: schemas.UpdateMediaBuyRequestSchema, + get_media_buys: schemas.GetMediaBuysRequestSchema, + get_media_buy_delivery: schemas.GetMediaBuyDeliveryRequestSchema, + provide_performance_feedback: schemas.ProvidePerformanceFeedbackRequestSchema, + + // Creative + list_creative_formats: schemas.ListCreativeFormatsRequestSchema, + build_creative: schemas.BuildCreativeRequestSchema, + // preview_creative is a z.union() (single/batch/variant) — not compatible with + // server.tool(name, schema.shape). Use the variant exports from index.ts instead: + // PreviewCreativeSingleRequestSchema, PreviewCreativeBatchRequestSchema, etc. + sync_creatives: schemas.SyncCreativesRequestSchema, + list_creatives: schemas.ListCreativesRequestSchema, + get_creative_delivery: schemas.GetCreativeDeliveryRequestSchema, + + // Signals + get_signals: schemas.GetSignalsRequestSchema, + activate_signal: schemas.ActivateSignalRequestSchema, + + // Account & audience + sync_accounts: schemas.SyncAccountsRequestSchema, + list_accounts: schemas.ListAccountsRequestSchema, + sync_governance: schemas.SyncGovernanceRequestSchema, + sync_audiences: schemas.SyncAudiencesRequestSchema, + report_usage: schemas.ReportUsageRequestSchema, + get_account_financials: schemas.GetAccountFinancialsRequestSchema, + + // Catalogs & events + sync_catalogs: schemas.SyncCatalogsRequestSchema, + sync_event_sources: schemas.SyncEventSourcesRequestSchema, + log_event: schemas.LogEventRequestSchema, + get_media_buy_artifacts: schemas.GetMediaBuyArtifactsRequestSchema, + + // Creative (additional) + get_creative_features: schemas.GetCreativeFeaturesRequestSchema, + + // Governance — property lists & content standards + create_property_list: schemas.CreatePropertyListRequestSchema, + get_property_list: schemas.GetPropertyListRequestSchema, + update_property_list: schemas.UpdatePropertyListRequestSchema, + list_property_lists: schemas.ListPropertyListsRequestSchema, + delete_property_list: schemas.DeletePropertyListRequestSchema, + list_content_standards: schemas.ListContentStandardsRequestSchema, + get_content_standards: schemas.GetContentStandardsRequestSchema, + create_content_standards: schemas.CreateContentStandardsRequestSchema, + update_content_standards: schemas.UpdateContentStandardsRequestSchema, + calibrate_content: schemas.CalibrateContentRequestSchema, + validate_content_delivery: schemas.ValidateContentDeliveryRequestSchema, + + // Campaign governance + sync_plans: schemas.SyncPlansRequestSchema, + check_governance: schemas.CheckGovernanceRequestSchema, + report_plan_outcome: schemas.ReportPlanOutcomeRequestSchema, + get_plan_audit_logs: schemas.GetPlanAuditLogsRequestSchema, + + // Collection lists + create_collection_list: schemas.CreateCollectionListRequestSchema, + update_collection_list: schemas.UpdateCollectionListRequestSchema, + get_collection_list: schemas.GetCollectionListRequestSchema, + list_collection_lists: schemas.ListCollectionListsRequestSchema, + delete_collection_list: schemas.DeleteCollectionListRequestSchema, + + // Sponsored Intelligence + si_get_offering: schemas.SIGetOfferingRequestSchema, + si_initiate_session: schemas.SIInitiateSessionRequestSchema, + si_send_message: schemas.SISendMessageRequestSchema, + si_terminate_session: schemas.SITerminateSessionRequestSchema, + + // Capabilities + get_adcp_capabilities: schemas.GetAdCPCapabilitiesRequestSchema, + + // Test controller + comply_test_controller: schemas.ComplyTestControllerRequestSchema, + + // Brand rights + get_brand_identity: schemas.GetBrandIdentityRequestSchema, + get_rights: schemas.GetRightsRequestSchema, + acquire_rights: schemas.AcquireRightsRequestSchema, +}; From d8e1c5623e9647228aa5c6f14aad3219dadadffc Mon Sep 17 00:00:00 2001 From: Brian O'Kelley Date: Wed, 15 Apr 2026 08:17:54 +0100 Subject: [PATCH 2/2] style: format generate-types.ts Co-Authored-By: Claude Opus 4.6 (1M context) --- scripts/generate-types.ts | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/scripts/generate-types.ts b/scripts/generate-types.ts index 64dad577..4b128fa1 100644 --- a/scripts/generate-types.ts +++ b/scripts/generate-types.ts @@ -1213,16 +1213,24 @@ function schemaPathToTypeName(relativePath: string): string { * - Schemas whose type names were already generated via $ref resolution * - Async response variant schemas (working/submitted/input-required) */ -async function compileGapSchemas( - generatedTypes: Set, - refResolver: any, -): Promise { +async function compileGapSchemas(generatedTypes: Set, refResolver: any): Promise { const allFiles = discoverAllSchemaFiles(LATEST_CACHE_DIR); const gapCode: string[] = []; // Directories that contain task request/response schemas (already covered by tool generation) - const taskDirs = new Set(['account', 'media-buy', 'creative', 'signals', 'governance', - 'protocol', 'sponsored-intelligence', 'compliance', 'content-standards', 'property', 'collection']); + const taskDirs = new Set([ + 'account', + 'media-buy', + 'creative', + 'signals', + 'governance', + 'protocol', + 'sponsored-intelligence', + 'compliance', + 'content-standards', + 'property', + 'collection', + ]); // Patterns that indicate task request/response schemas const taskSchemaPattern = /-(request|response)\.json$/;