Module adcp.types.registry

Registry API types generated from OpenAPI spec.

DO NOT EDIT — regenerate with: python scripts/generate_registry_types.py

Source: schemas/registry-openapi.yaml

Classes

class ActivityRevision (**data: Any)
Expand source code 
class ActivityRevision(RegistryBaseModel):
    revision_number: Annotated[int, Field(examples=[3])]
    editor_name: Annotated[str, Field(examples=["Pinnacle Media"])]
    edit_summary: Annotated[str, Field(examples=["Updated logo and brand colors"])]
    source: Annotated[
        str | None,
        Field(
            description="BrandSource type of the record at the time of this revision (brand_json, enriched, community)"
        ),
    ] = None
    is_rollback: bool
    rolled_back_to: Annotated[
        int | None,
        Field(
            description="ActivityRevision number that was restored; only present when is_rollback is true"
        ),
    ] = None
    created_at: Annotated[str, Field(examples=["2026-03-01T12:34:56Z"])]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var created_at : str
var edit_summary : str
var editor_name : str
var is_rollback : bool
var model_config
var revision_number : int
var rolled_back_to : int | None
var source : str | None
class AgentCapabilities (**data: Any)
Expand source code 
class AgentCapabilities(RegistryBaseModel):
    tools_count: int
    tools: list[AgentTool] | None = None
    standard_operations: AgentStandardOperations | None = None
    creative_capabilities: AgentCreativeCapabilities | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var creative_capabilities : AgentCreativeCapabilities | None
var model_config
var standard_operations : AgentStandardOperations | None
var tools : list[AgentTool] | None
var tools_count : int
class AgentCompliance (**data: Any)
Expand source code 
class AgentCompliance(RegistryBaseModel):
    status: ComplianceStatus
    lifecycle_stage: AgentLifecycleStage
    tracks: Annotated[dict[str, str], Field(examples=[{"core": "pass", "products": "fail"}])]
    streak_days: int
    last_checked_at: str | None
    headline: str | None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var headline : str | None
var last_checked_at : str | None
var lifecycle_stage : AgentLifecycleStage
var model_config
var status : ComplianceStatus
var streak_days : int
var tracks : dict[str, str]
class AgentContact (**data: Any)
Expand source code 
class AgentContact(RegistryBaseModel):
    name: str | None = None
    email: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var email : str | None
var model_config
var name : str | None
class AgentCreativeCapabilities (**data: Any)
Expand source code 
class AgentCreativeCapabilities(RegistryBaseModel):
    formats_supported: list[str]
    can_generate: bool
    can_validate: bool
    can_preview: bool

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var can_generate : bool
var can_preview : bool
var can_validate : bool
var formats_supported : list[str]
var model_config
class AgentDetailedContact (**data: Any)
Expand source code 
class AgentDetailedContact(RegistryBaseModel):
    name: str
    email: str
    website: str

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var email : str
var model_config
var name : str
var website : str
class AgentDiscoveredFrom (**data: Any)
Expand source code 
class AgentDiscoveredFrom(RegistryBaseModel):
    publisher_domain: str | None = None
    authorized_for: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var authorized_for : str | None
var model_config
var publisher_domain : str | None
class AgentHealth (**data: Any)
Expand source code 
class AgentHealth(RegistryBaseModel):
    online: bool
    checked_at: str
    response_time_ms: float | None = None
    tools_count: int | None = None
    resources_count: int | None = None
    error: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var checked_at : str
var error : str | None
var model_config
var online : bool
var resources_count : int | None
var response_time_ms : float | None
var tools_count : int | None
class AgentLifecycleStage (*args, **kwds)
Expand source code 
class AgentLifecycleStage(Enum):
    development = "development"
    testing = "testing"
    production = "production"
    deprecated = "deprecated"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var deprecated
var development
var production
var testing
class AgentMember (**data: Any)
Expand source code 
class AgentMember(RegistryBaseModel):
    slug: str | None = None
    display_name: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var display_name : str | None
var model_config
var slug : str | None
class AgentProtocol (*args, **kwds)
Expand source code 
class AgentProtocol(Enum):
    mcp = "mcp"
    a2a = "a2a"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var a2a
var mcp
class AgentSource (*args, **kwds)
Expand source code 
class AgentSource(Enum):
    registered = "registered"
    discovered = "discovered"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var discovered
var registered
class AgentStandardOperations (**data: Any)
Expand source code 
class AgentStandardOperations(RegistryBaseModel):
    can_search_inventory: bool
    can_get_availability: bool
    can_reserve_inventory: bool
    can_get_pricing: bool
    can_create_order: bool
    can_list_properties: bool

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var can_create_order : bool
var can_get_availability : bool
var can_get_pricing : bool
var can_list_properties : bool
var can_reserve_inventory : bool
var can_search_inventory : bool
var model_config
class AgentStats (**data: Any)
Expand source code 
class AgentStats(RegistryBaseModel):
    property_count: int | None = None
    publisher_count: int | None = None
    publishers: list[str] | None = None
    creative_formats: int | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var creative_formats : int | None
var model_config
var property_count : int | None
var publisher_count : int | None
var publishers : list[str] | None
class AgentTool (**data: Any)
Expand source code 
class AgentTool(RegistryBaseModel):
    name: str
    description: str

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var description : str
var model_config
var name : str
class AgentType (*args, **kwds)
Expand source code 
class AgentType(Enum):
    creative = "creative"
    signals = "signals"
    sales = "sales"
    governance = "governance"
    si = "si"
    unknown = "unknown"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var creative
var governance
var sales
var si
var signals
var unknown
class AuthorizedAgent (**data: Any)
Expand source code 
class AuthorizedAgent(RegistryBaseModel):
    url: str
    authorized_for: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var authorized_for : str | None
var model_config
var url : str
class BrandActivity (**data: Any)
Expand source code 
class BrandActivity(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["acmecorp.com"])]
    total: Annotated[int, Field(examples=[3])]
    revisions: list[ActivityRevision]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var domain : str
var model_config
var revisions : list[ActivityRevision]
var total : int
class BrandRegistryItem (**data: Any)
Expand source code 
class BrandRegistryItem(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["acmecorp.com"])]
    brand_name: Annotated[str | None, Field(examples=["Acme Corp"])] = None
    source: BrandRegistrySource
    has_manifest: bool
    verified: bool
    house_domain: str | None = None
    keller_type: KellerType | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var brand_name : str | None
var domain : str
var has_manifest : bool
var house_domain : str | None
var keller_type : KellerType | None
var model_config
var source : BrandRegistrySource
var verified : bool
class BrandRegistrySource (*args, **kwds)
Expand source code 
class BrandRegistrySource(Enum):
    hosted = "hosted"
    brand_json = "brand_json"
    community = "community"
    enriched = "enriched"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var brand_json
var community
var enriched
var hosted
class BrandSource (*args, **kwds)
Expand source code 
class BrandSource(Enum):
    brand_json = "brand_json"
    community = "community"
    enriched = "enriched"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var brand_json
var community
var enriched
class ComplianceStatus (*args, **kwds)
Expand source code 
class ComplianceStatus(Enum):
    passing = "passing"
    degraded = "degraded"
    failing = "failing"
    unknown = "unknown"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var degraded
var failing
var passing
var unknown
class DomainAuthorizedAgent (**data: Any)
Expand source code 
class DomainAuthorizedAgent(RegistryBaseModel):
    url: str
    authorized_for: str | None = None
    source: AgentSource | None = None
    member: AgentMember | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var authorized_for : str | None
var member : AgentMember | None
var model_config
var source : AgentSource | None
var url : str
class DomainLookupResult (**data: Any)
Expand source code 
class DomainLookupResult(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["examplepub.com"])]
    authorized_agents: list[DomainAuthorizedAgent]
    sales_agents_claiming: list[SalesAgentClaim]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var authorized_agents : list[DomainAuthorizedAgent]
var domain : str
var model_config
var sales_agents_claiming : list[SalesAgentClaim]
class FederatedAgentWithDetails (**data: Any)
Expand source code 
class FederatedAgentWithDetails(RegistryBaseModel):
    url: str
    name: str
    type: AgentType
    protocol: AgentProtocol | None = None
    description: str | None = None
    mcp_endpoint: str | None = None
    contact: AgentDetailedContact | None = None
    added_date: str | None = None
    source: AgentSource | None = None
    member: AgentMember | None = None
    discovered_from: AgentDiscoveredFrom | None = None
    health: AgentHealth | None = None
    stats: AgentStats | None = None
    capabilities: AgentCapabilities | None = None
    compliance: AgentCompliance | None = None
    publisher_domains: list[str] | None = None
    property_summary: PropertySummary | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var added_date : str | None
var capabilities : AgentCapabilities | None
var compliance : AgentCompliance | None
var contact : AgentDetailedContact | None
var description : str | None
var discovered_from : AgentDiscoveredFrom | None
var health : AgentHealth | None
var mcp_endpoint : str | None
var member : AgentMember | None
var model_config
var name : str
var property_summary : PropertySummary | None
var protocol : AgentProtocol | None
var publisher_domains : list[str] | None
var source : AgentSource | None
var stats : AgentStats | None
var type : AgentType
var url : str
class FederatedPublisher (**data: Any)
Expand source code 
class FederatedPublisher(RegistryBaseModel):
    domain: str
    source: AgentSource | None = None
    member: AgentMember | None = None
    agent_count: int | None = None
    last_validated: str | None = None
    discovered_from: PublisherDiscoveredFrom | None = None
    has_valid_adagents: bool | None = None
    discovered_at: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var agent_count : int | None
var discovered_at : str | None
var discovered_from : PublisherDiscoveredFrom | None
var domain : str
var has_valid_adagents : bool | None
var last_validated : str | None
var member : AgentMember | None
var model_config
var source : AgentSource | None
class FeedEvent (**data: Any)
Expand source code 
class FeedEvent(RegistryBaseModel):
    """Single event from the registry change feed."""

    event_id: str
    event_type: str
    entity_type: str
    entity_id: str
    payload: dict[str, Any] = Field(default_factory=dict)
    actor: str
    created_at: str

Single event from the registry change feed.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var actor : str
var created_at : str
var entity_id : str
var entity_type : str
var event_id : str
var event_type : str
var model_config
var payload : dict[str, typing.Any]
class FeedPage (**data: Any)
Expand source code 
class FeedPage(RegistryBaseModel):
    """Page of events from the registry change feed."""

    events: list[FeedEvent] = Field(default_factory=list)
    cursor: str | None = None
    has_more: bool

Page of events from the registry change feed.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var cursor : str | None
var events : list[FeedEvent]
var has_more : bool
var model_config
class KellerType (*args, **kwds)
Expand source code 
class KellerType(Enum):
    master = "master"
    sub_brand = "sub_brand"
    endorsed = "endorsed"
    independent = "independent"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var endorsed
var independent
var master
var sub_brand
class Policy (**data: Any)
Expand source code 
class Policy(RegistryBaseModel):
    policy_id: Annotated[str, Field(examples=["gdpr_consent"])]
    version: Annotated[str, Field(examples=["1.0.0"])]
    name: Annotated[str, Field(examples=["GDPR Consent Requirements"])]
    description: Annotated[
        str | None, Field(examples=["Requirements for valid consent under GDPR"])
    ]
    category: PolicyCategory
    enforcement: PolicyEnforcement
    jurisdictions: Annotated[list[str], Field(examples=[["EU", "EEA"]])]
    region_aliases: Annotated[dict[str, list[str]], Field(examples=[{"EU": ["DE", "FR", "IT"]}])]
    policy_categories: Annotated[
        list[str], Field(examples=[["age_restricted", "pharmaceutical_advertising"]])
    ]
    channels: Annotated[list[str] | None, Field(examples=[["display", "video"]])]
    governance_domains: Annotated[list[str], Field(examples=[["campaign", "creative"]])]
    effective_date: Annotated[str | None, Field(examples=["2025-05-25"])]
    sunset_date: str | None
    source_url: Annotated[
        str | None, Field(examples=["https://eur-lex.europa.eu/eli/reg/2016/679/oj"])
    ]
    source_name: Annotated[str | None, Field(examples=["EUR-Lex"])]
    policy: Annotated[
        str,
        Field(
            examples=[
                "Data subjects must provide freely given, specific, informed and unambiguous consent..."
            ]
        ),
    ]
    guidance: str | None
    exemplars: PolicyExemplars | None
    ext: dict[str, Any] | None
    source_type: PolicySourceType
    review_status: PolicyReviewStatus
    created_at: Annotated[str, Field(examples=["2026-03-01T12:00:00.000Z"])]
    updated_at: Annotated[str, Field(examples=["2026-03-01T12:00:00.000Z"])]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var category : PolicyCategory
var channels : list[str] | None
var created_at : str
var description : str | None
var effective_date : str | None
var enforcement : PolicyEnforcement
var exemplars : PolicyExemplars | None
var ext : dict[str, typing.Any] | None
var governance_domains : list[str]
var guidance : str | None
var jurisdictions : list[str]
var model_config
var name : str
var policy : str
var policy_categories : list[str]
var policy_id : str
var region_aliases : dict[str, list[str]]
var review_status : PolicyReviewStatus
var source_name : str | None
var source_type : PolicySourceType
var source_url : str | None
var sunset_date : str | None
var updated_at : str
var version : str
class PolicyCategory (*args, **kwds)
Expand source code 
class PolicyCategory(Enum):
    regulation = "regulation"
    standard = "standard"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var regulation
var standard
class PolicyEnforcement (*args, **kwds)
Expand source code 
class PolicyEnforcement(Enum):
    must = "must"
    should = "should"
    may = "may"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var may
var must
var should
class PolicyExemplarFail (**data: Any)
Expand source code 
class PolicyExemplarFail(RegistryBaseModel):
    scenario: Annotated[str, Field(examples=["Ad for alcohol shown during children's programming"])]
    explanation: Annotated[
        str, Field(examples=["Violates watershed timing rules for alcohol advertising"])
    ]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var explanation : str
var model_config
var scenario : str
class PolicyExemplarPass (**data: Any)
Expand source code 
class PolicyExemplarPass(RegistryBaseModel):
    scenario: Annotated[str, Field(examples=["Ad for alcohol shown during children's programming"])]
    explanation: Annotated[
        str, Field(examples=["Violates watershed timing rules for alcohol advertising"])
    ]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var explanation : str
var model_config
var scenario : str
class PolicyExemplars (**data: Any)
Expand source code 
class PolicyExemplars(RegistryBaseModel):
    pass_: Annotated[list[PolicyExemplarPass] | None, Field(alias="pass")] = None
    fail: list[PolicyExemplarFail] | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var fail : list[PolicyExemplarFail] | None
var model_config
var pass_ : list[PolicyExemplarPass] | None
class PolicyHistory (**data: Any)
Expand source code 
class PolicyHistory(RegistryBaseModel):
    policy_id: Annotated[str, Field(examples=["gdpr_consent"])]
    total: Annotated[int, Field(examples=[3])]
    revisions: list[PolicyRevision]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var model_config
var policy_id : str
var revisions : list[PolicyRevision]
var total : int
class PolicyReviewStatus (*args, **kwds)
Expand source code 
class PolicyReviewStatus(Enum):
    pending = "pending"
    approved = "approved"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var approved
var pending
class PolicyRevision (**data: Any)
Expand source code 
class PolicyRevision(RegistryBaseModel):
    revision_number: Annotated[int, Field(examples=[2])]
    editor_name: Annotated[str, Field(examples=["Pinnacle Media"])]
    edit_summary: Annotated[str, Field(examples=["Clarified consent requirements for minors"])]
    is_rollback: bool
    rolled_back_to: Annotated[
        int | None,
        Field(
            description="ActivityRevision number that was restored; only present when is_rollback is true"
        ),
    ] = None
    created_at: Annotated[str, Field(examples=["2026-03-01T12:34:56Z"])]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var created_at : str
var edit_summary : str
var editor_name : str
var is_rollback : bool
var model_config
var revision_number : int
var rolled_back_to : int | None
class PolicySourceType (*args, **kwds)
Expand source code 
class PolicySourceType(Enum):
    registry = "registry"
    community = "community"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var community
var registry
class PolicySummary (**data: Any)
Expand source code 
class PolicySummary(RegistryBaseModel):
    policy_id: Annotated[str, Field(examples=["gdpr_consent"])]
    version: Annotated[str, Field(examples=["1.0.0"])]
    name: Annotated[str, Field(examples=["GDPR Consent Requirements"])]
    description: Annotated[
        str | None, Field(examples=["Requirements for valid consent under GDPR"])
    ]
    category: PolicyCategory
    enforcement: PolicyEnforcement
    jurisdictions: Annotated[list[str], Field(examples=[["EU", "EEA"]])]
    region_aliases: Annotated[dict[str, list[str]], Field(examples=[{"EU": ["DE", "FR", "IT"]}])]
    policy_categories: Annotated[
        list[str], Field(examples=[["age_restricted", "pharmaceutical_advertising"]])
    ]
    channels: Annotated[list[str] | None, Field(examples=[["display", "video"]])]
    governance_domains: Annotated[list[str], Field(examples=[["campaign", "creative"]])]
    effective_date: Annotated[str | None, Field(examples=["2025-05-25"])]
    sunset_date: str | None
    source_url: Annotated[
        str | None, Field(examples=["https://eur-lex.europa.eu/eli/reg/2016/679/oj"])
    ]
    source_name: Annotated[str | None, Field(examples=["EUR-Lex"])]
    source_type: PolicySourceType
    review_status: PolicyReviewStatus
    created_at: Annotated[str, Field(examples=["2026-03-01T12:00:00.000Z"])]
    updated_at: Annotated[str, Field(examples=["2026-03-01T12:00:00.000Z"])]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var category : PolicyCategory
var channels : list[str] | None
var created_at : str
var description : str | None
var effective_date : str | None
var enforcement : PolicyEnforcement
var governance_domains : list[str]
var jurisdictions : list[str]
var model_config
var name : str
var policy_categories : list[str]
var policy_id : str
var region_aliases : dict[str, list[str]]
var review_status : PolicyReviewStatus
var source_name : str | None
var source_type : PolicySourceType
var source_url : str | None
var sunset_date : str | None
var updated_at : str
var version : str
class PropertyActivity (**data: Any)
Expand source code 
class PropertyActivity(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["examplepub.com"])]
    total: Annotated[int, Field(examples=[3])]
    revisions: list[ActivityRevision]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var domain : str
var model_config
var revisions : list[ActivityRevision]
var total : int
class PropertyIdentifier (**data: Any)
Expand source code 
class PropertyIdentifier(RegistryBaseModel):
    type: Annotated[str, Field(examples=["domain"])]
    value: Annotated[str, Field(examples=["examplepub.com"])]

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var model_config
var type : str
var value : str
class PropertyRegistryItem (**data: Any)
Expand source code 
class PropertyRegistryItem(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["examplepub.com"])]
    source: PropertyRegistrySource
    property_count: int
    agent_count: int
    verified: bool

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var agent_count : int
var domain : str
var model_config
var property_count : int
var source : PropertyRegistrySource
var verified : bool
class PropertyRegistrySource (*args, **kwds)
Expand source code 
class PropertyRegistrySource(Enum):
    adagents_json = "adagents_json"
    hosted = "hosted"
    community = "community"
    discovered = "discovered"
    enriched = "enriched"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var adagents_json
var community
var discovered
var enriched
var hosted
class PropertySource (*args, **kwds)
Expand source code 
class PropertySource(Enum):
    adagents_json = "adagents_json"
    hosted = "hosted"
    discovered = "discovered"

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

  • attribute access::
>>> Color.RED
<Color.RED: 1>
  • value lookup:
>>> Color(1)
<Color.RED: 1>
  • name lookup:
>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

Ancestors

  • enum.Enum

Class variables

var adagents_json
var discovered
var hosted
class PropertySummary (**data: Any)
Expand source code 
class PropertySummary(RegistryBaseModel):
    total_count: int
    count_by_type: dict[str, int]
    tags: list[str]
    publisher_count: int

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var count_by_type : dict[str, int]
var model_config
var publisher_count : int
var tags : list[str]
var total_count : int
class PublisherDiscoveredFrom (**data: Any)
Expand source code 
class PublisherDiscoveredFrom(RegistryBaseModel):
    agent_url: str | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var agent_url : str | None
var model_config
class PublisherPropertySelector (**data: Any)
Expand source code 
class PublisherPropertySelector(RegistryBaseModel):
    publisher_domain: Annotated[str | None, Field(examples=["examplepub.com"])] = None
    property_types: list[str] | None = None
    property_ids: list[str] | None = None
    tags: list[str] | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var model_config
var property_ids : list[str] | None
var property_types : list[str] | None
var publisher_domain : str | None
var tags : list[str] | None
class RegistryApiError (**data: Any)
Expand source code 
class RegistryApiError(RegistryBaseModel):
    error: str

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var error : str
var model_config
class ResolvedBrand (**data: Any)
Expand source code 
class ResolvedBrand(RegistryBaseModel):
    canonical_id: Annotated[str, Field(examples=["acmecorp.com"])]
    canonical_domain: Annotated[str, Field(examples=["acmecorp.com"])]
    brand_name: Annotated[str, Field(examples=["Acme Corp"])]
    names: list[dict[str, str]] | None = None
    keller_type: KellerType | None = None
    parent_brand: str | None = None
    house_domain: str | None = None
    house_name: str | None = None
    brand_agent_url: str | None = None
    brand_manifest: dict[str, Any] | None = None
    source: BrandSource

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var brand_agent_url : str | None
var brand_manifest : dict[str, typing.Any] | None
var brand_name : str
var canonical_domain : str
var canonical_id : str
var house_domain : str | None
var house_name : str | None
var keller_type : KellerType | None
var model_config
var names : list[dict[str, str]] | None
var parent_brand : str | None
var source : BrandSource
class ResolvedProperty (**data: Any)
Expand source code 
class ResolvedProperty(RegistryBaseModel):
    publisher_domain: Annotated[str, Field(examples=["examplepub.com"])]
    source: PropertySource
    authorized_agents: list[AuthorizedAgent] | None = None
    properties: list[ResolvedPropertyEntry] | None = None
    contact: AgentContact | None = None
    verified: bool

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var authorized_agents : list[AuthorizedAgent] | None
var contact : AgentContact | None
var model_config
var properties : list[ResolvedPropertyEntry] | None
var publisher_domain : str
var source : PropertySource
var verified : bool
class ResolvedPropertyEntry (**data: Any)
Expand source code 
class ResolvedPropertyEntry(RegistryBaseModel):
    id: str | None = None
    type: str | None = None
    name: str | None = None
    identifiers: list[PropertyIdentifier] | None = None
    tags: list[str] | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var id : str | None
var identifiers : list[PropertyIdentifier] | None
var model_config
var name : str | None
var tags : list[str] | None
var type : str | None
class SalesAgentClaim (**data: Any)
Expand source code 
class SalesAgentClaim(RegistryBaseModel):
    url: str
    source: AgentSource | None = None
    member: AgentMember | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var member : AgentMember | None
var model_config
var source : AgentSource | None
var url : str
class ValidationResult (**data: Any)
Expand source code 
class ValidationResult(RegistryBaseModel):
    valid: bool
    domain: str | None = None
    url: str | None = None
    errors: list[str | dict[str, Any]] | None = None
    warnings: list[str | dict[str, Any]] | None = None
    status_code: int | None = None
    raw_data: dict[str, Any] | None = None

Base model for registry API types.

Uses extra='allow' so that new fields from the registry API are preserved rather than dropped. This differs from AdCPBaseModel which defaults to extra='ignore' for protocol types.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

Class variables

var domain : str | None
var errors : list[str | dict[str, typing.Any]] | None
var model_config
var raw_data : dict[str, typing.Any] | None
var status_code : int | None
var url : str | None
var valid : bool
var warnings : list[str | dict[str, typing.Any]] | None