@adcp/client 3.14.1 → 3.16.0

package/dist/lib/registry/types.generated.d.ts

@@ -0,0 +1,1860 @@
+export interface paths {
+    "/api": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * API discovery
+         * @description Returns links to the main API entry points and documentation.
+         */
+        get: operations["apiDiscovery"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Resolve brand
+         * @description Resolve a domain to its canonical brand identity. Follows brand.json redirects and returns the resolved brand with its house, architecture type, and optional manifest.
+         */
+        get: operations["resolveBrand"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/resolve/bulk": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bulk resolve brands
+         * @description Resolve up to 100 domains to their canonical brand identities in a single request.
+         *
+         *     **Rate limit:** 20 requests per minute per IP address.
+         */
+        post: operations["resolveBrandsBulk"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/brand-json": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get brand.json
+         * @description Fetch the raw brand.json file for a domain.
+         */
+        get: operations["getBrandJson"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/save": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Save brand
+         * @description Save or update a brand in the registry. Requires authentication. For existing brands, creates a revision-tracked edit. For new brands, creates the brand directly. Cannot edit authoritative brands managed via brand.json.
+         */
+        post: operations["saveBrand"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/registry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List brands
+         * @description List all brands in the registry with optional search, pagination.
+         */
+        get: operations["listBrands"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/brands/enrich": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Enrich brand
+         * @description Enrich brand data using Brandfetch. Returns logo, colors, and company information.
+         */
+        get: operations["enrichBrand"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/properties/resolve": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Resolve property
+         * @description Resolve a publisher domain to its property information. Checks hosted properties, discovered properties, then live adagents.json validation.
+         */
+        get: operations["resolveProperty"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/properties/resolve/bulk": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Bulk resolve properties
+         * @description Resolve up to 100 publisher domains at once.
+         *
+         *     **Rate limit:** 20 requests per minute per IP address.
+         */
+        post: operations["resolvePropertiesBulk"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/properties/registry": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List properties
+         * @description List all properties in the registry with optional search, pagination.
+         */
+        get: operations["listProperties"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/properties/validate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Validate adagents.json
+         * @description Validate a domain's adagents.json file and return the validation result.
+         */
+        get: operations["validateProperty"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/properties/save": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Save property
+         * @description Save or update a hosted property in the registry. Requires authentication. For existing properties, creates a revision-tracked edit. For new properties, creates the property directly. Cannot edit authoritative properties managed via adagents.json.
+         */
+        post: operations["saveProperty"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/agents": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List agents
+         * @description List all registered and discovered agents. Optionally enrich with health checks, capabilities, and property summaries via query parameters.
+         */
+        get: operations["listAgents"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/publishers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List publishers
+         * @description List all registered and discovered publishers.
+         */
+        get: operations["listPublishers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/stats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Registry statistics
+         * @description Get aggregate statistics about the registry.
+         */
+        get: operations["getRegistryStats"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/lookup/domain/{domain}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Domain lookup
+         * @description Find all agents authorized for a given publisher domain.
+         */
+        get: operations["lookupDomain"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/lookup/property": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Property identifier lookup
+         * @description Find agents that hold a specific property identifier.
+         */
+        get: operations["lookupProperty"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/lookup/agent/{agentUrl}/domains": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Agent domain lookup
+         * @description Get all publisher domains associated with an agent.
+         */
+        get: operations["getAgentDomains"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/validate/product-authorization": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate product authorization
+         * @description Check whether an agent is authorized to sell a product based on its publisher_properties.
+         */
+        post: operations["validateProductAuthorization"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/expand/product-identifiers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Expand product identifiers
+         * @description Expand publisher_properties selectors into concrete property identifiers for caching.
+         */
+        post: operations["expandProductIdentifiers"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/registry/validate/property-authorization": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Property authorization check
+         * @description Quick check if a property identifier is authorized for an agent. Optimized for real-time ad request validation.
+         */
+        get: operations["validatePropertyAuthorization"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/adagents/validate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate adagents.json
+         * @description Validate a domain's adagents.json file and optionally validate referenced agent cards.
+         */
+        post: operations["validateAdagents"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/adagents/create": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Generate adagents.json
+         * @description Generate a valid adagents.json file from a list of authorized agents.
+         */
+        post: operations["createAdagents"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search
+         * @description Search across brands, publishers, and properties. Returns up to 5 results per category.
+         */
+        get: operations["search"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/manifest-refs/lookup": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Manifest reference lookup
+         * @description Find the best manifest reference (brand.json URL or agent) for a domain.
+         */
+        get: operations["lookupManifestRef"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/public/discover-agent": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Discover agent
+         * @description Probe an agent URL to discover its name, type, supported protocols, and basic statistics.
+         */
+        get: operations["discoverAgent"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/public/agent-formats": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get agent formats
+         * @description Fetch creative formats from a creative agent.
+         */
+        get: operations["getAgentFormats"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/public/agent-products": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get agent products
+         * @description Fetch products from a sales agent.
+         */
+        get: operations["getAgentProducts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/public/validate-publisher": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Validate publisher
+         * @description Validate a publisher domain's adagents.json and return summary statistics.
+         */
+        get: operations["validatePublisher"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        ResolvedBrand: {
+            /** @example acmecorp.com */
+            canonical_id: string;
+            /** @example acmecorp.com */
+            canonical_domain: string;
+            /** @example Acme Corp */
+            brand_name: string;
+            names?: components["schemas"]["LocalizedName"][];
+            /** @enum {string} */
+            keller_type?: "master" | "sub_brand" | "endorsed" | "independent";
+            parent_brand?: string;
+            house_domain?: string;
+            house_name?: string;
+            brand_agent_url?: string;
+            brand_manifest?: {
+                [key: string]: unknown;
+            };
+            /** @enum {string} */
+            source: "brand_json" | "community" | "enriched";
+        };
+        LocalizedName: {
+            [key: string]: string;
+        };
+        Error: {
+            error: string;
+        };
+        BrandRegistryItem: {
+            /** @example acmecorp.com */
+            domain: string;
+            /** @example Acme Corp */
+            brand_name?: string;
+            /** @enum {string} */
+            source: "hosted" | "brand_json" | "community" | "enriched";
+            has_manifest: boolean;
+            verified: boolean;
+            house_domain?: string;
+            /** @enum {string} */
+            keller_type?: "master" | "sub_brand" | "endorsed" | "independent";
+        };
+        ResolvedProperty: {
+            /** @example examplepub.com */
+            publisher_domain: string;
+            /** @enum {string} */
+            source: "adagents_json" | "hosted" | "discovered";
+            authorized_agents?: {
+                url: string;
+                authorized_for?: string;
+            }[];
+            properties?: {
+                id?: string;
+                type?: string;
+                name?: string;
+                identifiers?: components["schemas"]["PropertyIdentifier"][];
+                tags?: string[];
+            }[];
+            contact?: {
+                name?: string;
+                email?: string;
+            };
+            verified: boolean;
+        };
+        PropertyIdentifier: {
+            /** @example domain */
+            type: string;
+            /** @example examplepub.com */
+            value: string;
+        };
+        PropertyRegistryItem: {
+            /** @example examplepub.com */
+            domain: string;
+            /** @enum {string} */
+            source: "adagents_json" | "hosted" | "community" | "discovered" | "enriched";
+            property_count: number;
+            agent_count: number;
+            verified: boolean;
+        };
+        ValidationResult: {
+            valid: boolean;
+            domain?: string;
+            url?: string;
+            errors?: string[];
+            warnings?: string[];
+            status_code?: number;
+            raw_data?: {
+                [key: string]: unknown;
+            };
+        };
+        FederatedAgentWithDetails: {
+            url: string;
+            name: string;
+            /** @enum {string} */
+            type: "creative" | "signals" | "sales" | "governance" | "si" | "unknown";
+            /** @enum {string} */
+            protocol?: "mcp" | "a2a";
+            description?: string;
+            mcp_endpoint?: string;
+            contact?: {
+                name: string;
+                email: string;
+                website: string;
+            };
+            added_date?: string;
+            /** @enum {string} */
+            source?: "registered" | "discovered";
+            member?: {
+                slug?: string;
+                display_name?: string;
+            };
+            discovered_from?: {
+                publisher_domain?: string;
+                authorized_for?: string;
+            };
+            health?: components["schemas"]["AgentHealth"];
+            stats?: components["schemas"]["AgentStats"];
+            capabilities?: components["schemas"]["AgentCapabilities"];
+            publisher_domains?: string[];
+            property_summary?: components["schemas"]["PropertySummary"];
+        };
+        AgentHealth: {
+            online: boolean;
+            checked_at: string;
+            response_time_ms?: number;
+            tools_count?: number;
+            resources_count?: number;
+            error?: string;
+        };
+        AgentStats: {
+            property_count?: number;
+            publisher_count?: number;
+            publishers?: string[];
+            creative_formats?: number;
+        };
+        AgentCapabilities: {
+            tools_count: number;
+            tools?: {
+                name: string;
+                description: string;
+            }[];
+            standard_operations?: {
+                can_search_inventory: boolean;
+                can_get_availability: boolean;
+                can_reserve_inventory: boolean;
+                can_get_pricing: boolean;
+                can_create_order: boolean;
+                can_list_properties: boolean;
+            };
+            creative_capabilities?: {
+                formats_supported: string[];
+                can_generate: boolean;
+                can_validate: boolean;
+                can_preview: boolean;
+            };
+        };
+        PropertySummary: {
+            total_count: number;
+            count_by_type: {
+                [key: string]: number;
+            };
+            tags: string[];
+            publisher_count: number;
+        };
+        FederatedPublisher: {
+            domain: string;
+            /** @enum {string} */
+            source?: "registered" | "discovered";
+            member?: {
+                slug?: string;
+                display_name?: string;
+            };
+            agent_count?: number;
+            last_validated?: string;
+            discovered_from?: {
+                agent_url?: string;
+            };
+            has_valid_adagents?: boolean;
+            discovered_at?: string;
+        };
+        DomainLookupResult: {
+            /** @example examplepub.com */
+            domain: string;
+            authorized_agents: {
+                url: string;
+                authorized_for?: string;
+                /** @enum {string} */
+                source?: "registered" | "discovered";
+                member?: {
+                    slug?: string;
+                    display_name?: string;
+                };
+            }[];
+            sales_agents_claiming: {
+                url: string;
+                /** @enum {string} */
+                source?: "registered" | "discovered";
+                member?: {
+                    slug?: string;
+                    display_name?: string;
+                };
+            }[];
+        };
+        PublisherPropertySelector: {
+            /** @example examplepub.com */
+            publisher_domain?: string;
+            property_types?: string[];
+            property_ids?: string[];
+            tags?: string[];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export interface operations {
+    apiDiscovery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description API discovery information */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        name: string;
+                        version: string;
+                        documentation: string;
+                        openapi: string;
+                        endpoints: {
+                            [key: string]: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    resolveBrand: {
+        parameters: {
+            query: {
+                domain: string;
+                fresh?: "true" | "false";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Brand resolved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResolvedBrand"];
+                };
+            };
+            /** @description Brand not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        domain: string;
+                        /** @description HTTP status code from brand.json fetch (e.g. 404 vs 200 with invalid data) */
+                        file_status?: number;
+                    };
+                };
+            };
+        };
+    };
+    resolveBrandsBulk: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    domains: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Bulk resolution results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        results: {
+                            [key: string]: components["schemas"]["ResolvedBrand"] & (Record<string, never> | null);
+                        };
+                    };
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    getBrandJson: {
+        parameters: {
+            query: {
+                domain: string;
+                fresh?: "true" | "false";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Raw brand.json data */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        domain: string;
+                        url: string;
+                        variant?: string;
+                        data: {
+                            [key: string]: unknown;
+                        };
+                        warnings?: string[];
+                    };
+                };
+            };
+            /** @description Brand not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    saveBrand: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @example acmecorp.com */
+                    domain: string;
+                    /** @example Acme Corp */
+                    brand_name: string;
+                    brand_manifest?: {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description Brand saved or updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        success: true;
+                        message: string;
+                        domain: string;
+                        id: string;
+                        revision_number?: number;
+                    };
+                };
+            };
+            /** @description Missing required fields or invalid domain */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Cannot edit authoritative brand */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listBrands: {
+        parameters: {
+            query?: {
+                search?: string;
+                limit?: string;
+                offset?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Brand list with stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        brands: components["schemas"]["BrandRegistryItem"][];
+                        stats: {
+                            total: number;
+                            brand_json: number;
+                            hosted: number;
+                            community: number;
+                            enriched: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    enrichBrand: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Enrichment data from Brandfetch */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+            /** @description Brandfetch not configured */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    resolveProperty: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Property resolved */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ResolvedProperty"];
+                };
+            };
+            /** @description Property not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        domain: string;
+                    };
+                };
+            };
+        };
+    };
+    resolvePropertiesBulk: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    domains: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description Bulk resolution results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        results: {
+                            [key: string]: components["schemas"]["ResolvedProperty"] & (Record<string, never> | null);
+                        };
+                    };
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listProperties: {
+        parameters: {
+            query?: {
+                search?: string;
+                limit?: string;
+                offset?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Property list with stats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        properties: components["schemas"]["PropertyRegistryItem"][];
+                        stats: {
+                            [key: string]: unknown;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    validateProperty: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Validation result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidationResult"];
+                };
+            };
+        };
+    };
+    saveProperty: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    /** @example examplepub.com */
+                    publisher_domain: string;
+                    /**
+                     * @example [
+                     *       {
+                     *         "url": "https://agent.example.com"
+                     *       }
+                     *     ]
+                     */
+                    authorized_agents: {
+                        url: string;
+                        authorized_for?: string;
+                    }[];
+                    /**
+                     * @example [
+                     *       {
+                     *         "type": "website",
+                     *         "name": "Example Publisher"
+                     *       }
+                     *     ]
+                     */
+                    properties?: {
+                        type: string;
+                        name: string;
+                    }[];
+                    contact?: {
+                        name?: string;
+                        email?: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            /** @description Property saved or updated */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        success: true;
+                        message: string;
+                        id: string;
+                        revision_number?: number;
+                    };
+                };
+            };
+            /** @description Missing required fields or invalid domain */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Cannot edit authoritative property */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Rate limit exceeded */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    listAgents: {
+        parameters: {
+            query?: {
+                type?: "creative" | "signals" | "sales" | "governance" | "si" | "unknown";
+                health?: "true";
+                capabilities?: "true";
+                properties?: "true";
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Agent list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        agents: components["schemas"]["FederatedAgentWithDetails"][];
+                        count: number;
+                        sources: {
+                            registered: number;
+                            discovered: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    listPublishers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Publisher list */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        publishers: components["schemas"]["FederatedPublisher"][];
+                        count: number;
+                        sources: {
+                            registered: number;
+                            discovered: number;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    getRegistryStats: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Registry statistics */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    lookupDomain: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                domain: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Domain lookup result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DomainLookupResult"];
+                };
+            };
+        };
+    };
+    lookupProperty: {
+        parameters: {
+            query: {
+                type: string;
+                value: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Matching agents */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        type: string;
+                        value: string;
+                        agents: unknown[];
+                        count: number;
+                    };
+                };
+            };
+        };
+    };
+    getAgentDomains: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                agentUrl: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Domains for the agent */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        agent_url: string;
+                        domains: string[];
+                        count: number;
+                    };
+                };
+            };
+        };
+    };
+    validateProductAuthorization: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    agent_url: string;
+                    publisher_properties: components["schemas"]["PublisherPropertySelector"][];
+                };
+            };
+        };
+        responses: {
+            /** @description Authorization validation result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        agent_url: string;
+                        authorized: boolean;
+                        checked_at: string;
+                    } & {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    expandProductIdentifiers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    agent_url: string;
+                    publisher_properties: components["schemas"]["PublisherPropertySelector"][];
+                };
+            };
+        };
+        responses: {
+            /** @description Expanded identifiers */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        agent_url: string;
+                        properties: unknown[];
+                        identifiers: {
+                            type: string;
+                            value: string;
+                            property_id: string;
+                            publisher_domain: string;
+                        }[];
+                        property_count: number;
+                        identifier_count: number;
+                        generated_at: string;
+                    };
+                };
+            };
+        };
+    };
+    validatePropertyAuthorization: {
+        parameters: {
+            query: {
+                agent_url: string;
+                identifier_type: string;
+                identifier_value: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Authorization result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        agent_url: string;
+                        identifier_type: string;
+                        identifier_value: string;
+                        authorized: boolean;
+                        checked_at: string;
+                    } & {
+                        [key: string]: unknown;
+                    };
+                };
+            };
+        };
+    };
+    validateAdagents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    domain: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Validation result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        data: {
+                            domain: string;
+                            found: boolean;
+                            validation?: unknown;
+                            agent_cards?: unknown;
+                        };
+                        timestamp: string;
+                    };
+                };
+            };
+        };
+    };
+    createAdagents: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: {
+            content: {
+                "application/json": {
+                    authorized_agents: {
+                        url: string;
+                        authorized_for?: string;
+                    }[];
+                    include_schema?: boolean;
+                    include_timestamp?: boolean;
+                    properties?: unknown[];
+                };
+            };
+        };
+        responses: {
+            /** @description Generated adagents.json */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        data: {
+                            success: boolean;
+                            adagents_json?: unknown;
+                            validation?: unknown;
+                        };
+                        timestamp: string;
+                    };
+                };
+            };
+        };
+    };
+    search: {
+        parameters: {
+            query: {
+                q: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Search results */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        brands: unknown[];
+                        publishers: unknown[];
+                        properties: unknown[];
+                    };
+                };
+            };
+        };
+    };
+    lookupManifestRef: {
+        parameters: {
+            query: {
+                domain: string;
+                type?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Reference lookup result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /** @enum {boolean} */
+                        success: true;
+                        /** @enum {boolean} */
+                        found: true;
+                        reference: {
+                            /** @enum {string} */
+                            reference_type: "url" | "agent";
+                            manifest_url: string | null;
+                            agent_url: string | null;
+                            agent_id: string | null;
+                            /** @enum {string} */
+                            verification_status: "pending" | "valid" | "invalid" | "unreachable";
+                        };
+                    } | {
+                        /** @enum {boolean} */
+                        success: false;
+                        /** @enum {boolean} */
+                        found: false;
+                    };
+                };
+            };
+        };
+    };
+    discoverAgent: {
+        parameters: {
+            query: {
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Discovered agent info */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        name: string;
+                        description?: string;
+                        protocols: string[];
+                        type: string;
+                        stats: {
+                            format_count?: number;
+                            product_count?: number;
+                            publisher_count?: number;
+                        };
+                    };
+                };
+            };
+            /** @description Connection timeout */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: string;
+                        message: string;
+                    };
+                };
+            };
+        };
+    };
+    getAgentFormats: {
+        parameters: {
+            query: {
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Creative formats */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        formats: unknown[];
+                    };
+                };
+            };
+        };
+    };
+    getAgentProducts: {
+        parameters: {
+            query: {
+                url: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Products */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        success: boolean;
+                        products: unknown[];
+                    };
+                };
+            };
+        };
+    };
+    validatePublisher: {
+        parameters: {
+            query: {
+                domain: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Publisher validation result */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        valid: boolean;
+                        domain: string;
+                        url?: string;
+                        agent_count: number;
+                        property_count: number;
+                        property_type_counts: {
+                            [key: string]: number;
+                        };
+                        tag_count: number;
+                        errors?: string[];
+                        warnings?: string[];
+                    };
+                };
+            };
+        };
+    };
+}
+export type ResolvedBrand = components['schemas']['ResolvedBrand'];
+export type LocalizedName = components['schemas']['LocalizedName'];
+export type BrandRegistryItem = components['schemas']['BrandRegistryItem'];
+export type ResolvedProperty = components['schemas']['ResolvedProperty'];
+export type PropertyIdentifier = components['schemas']['PropertyIdentifier'];
+export type PropertyRegistryItem = components['schemas']['PropertyRegistryItem'];
+export type ValidationResult = components['schemas']['ValidationResult'];
+export type RegistryError = components['schemas']['Error'];
+export type PublisherPropertySelector = components['schemas']['PublisherPropertySelector'];
+export type FederatedAgentWithDetails = components['schemas']['FederatedAgentWithDetails'];
+export type AgentHealth = components['schemas']['AgentHealth'];
+export type AgentStats = components['schemas']['AgentStats'];
+export type AgentCapabilities = components['schemas']['AgentCapabilities'];
+export type PropertySummary = components['schemas']['PropertySummary'];
+export type FederatedPublisher = components['schemas']['FederatedPublisher'];
+export type DomainLookupResult = components['schemas']['DomainLookupResult'];
+//# sourceMappingURL=types.generated.d.ts.map