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 Accreditation (**data: Any)

Expand source code

class Accreditation(RegistryBaseModel):
    accrediting_body: str
    certification_id: str | None = None
    valid_until: str | None = None
    evidence_url: str | None = None
    verified_by_aao: Annotated[
        VerifiedByAao,
        Field(
            description="Always `false` — accreditation claims are vendor-asserted. AAO does not independently verify; renderers should mark these as vendor claims."
        ),
    ]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var accrediting_body : str

var certification_id : str | None

var evidence_url : str | None

var model_config

var valid_until : str | None

var verified_by_aao : VerifiedByAao

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 AdagentsAuthorizationType (*args, **kwds)

Expand source code

class AdagentsAuthorizationType(Enum):
    property_ids = "property_ids"
    property_tags = "property_tags"
    inline_properties = "inline_properties"
    publisher_properties = "publisher_properties"
    signal_ids = "signal_ids"
    signal_tags = "signal_tags"

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 inline_properties

var property_ids

var property_tags

var publisher_properties

var signal_ids

var signal_tags

class AdagentsAuthorizedAgent (**data: Any)

Expand source code

class AdagentsAuthorizedAgent(RegistryBaseModel):
    url: Annotated[AnyUrl, Field(description="Agent endpoint URL.")]
    authorized_for: str | None = None
    authorization_type: AdagentsAuthorizationType | None = None
    property_ids: list[str] | None = None
    property_tags: list[str] | None = None
    properties: list[dict[str, Any]] | None = None
    publisher_properties: list[AdagentsPublisherProperty] | None = None
    collections: list[CollectionRef] | None = None
    placement_ids: list[str] | None = None
    placement_tags: list[str] | None = None
    delegation_type: DelegationType | None = None
    exclusive: bool | None = None
    countries: list[str] | None = None
    effective_from: str | None = None
    effective_until: str | None = None
    signal_ids: list[str] | None = None
    signal_tags: list[str] | None = None
    signing_keys: list[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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : AdagentsAuthorizationType | None

var authorized_for : str | None

var collections : list[CollectionRef] | None

var countries : list[str] | None

var delegation_type : DelegationType | None

var effective_from : str | None

var effective_until : str | None

var exclusive : bool | None

var model_config

var placement_ids : list[str] | None

var placement_tags : list[str] | None

var properties : list[dict[str, typing.Any]] | None

var property_ids : list[str] | None

var property_tags : list[str] | None

var publisher_properties : list[AdagentsPublisherProperty] | None

var signal_ids : list[str] | None

var signal_tags : list[str] | None

var signing_keys : list[dict[str, typing.Any]] | None

var url : pydantic.networks.AnyUrl

class AdagentsDiscoveryMethod (*args, **kwds)

Expand source code

class AdagentsDiscoveryMethod(Enum):
    direct = "direct"
    authoritative_location = "authoritative_location"
    ads_txt_managerdomain = "ads_txt_managerdomain"
    adagents_authoritative = "adagents_authoritative"

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_authoritative

var ads_txt_managerdomain

var authoritative_location

var direct

class AdagentsJson (**data: Any)

Expand source code

class AdagentsJson(RegistryBaseModel):
    status: Annotated[
        Status1,
        Field(
            description="What we know about the publisher's adagents.json right now. `valid` = crawler fetched a parsing-and-shape-valid file from the publisher origin. `community` = moderators approved a community adagents.json catalog for this domain. `invalid` = crawler fetched a file that failed validation. `unknown` = never crawled or last result is stale. `checking` = an auto-crawl was kicked off by this request; the page should poll for fresh data shortly."
        ),
    ]
    expected_url: Annotated[
        str,
        Field(description="Where adagents.json should live on the publisher's own origin."),
    ]
    registry_url: Annotated[
        str | None,
        Field(
            description="Registry-served adagents.json URL when the document is community or AgenticAdvertising.org hosted rather than served by the publisher origin."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var expected_url : str

var model_config

var registry_url : str | None

var status : Status1

class AdagentsPublisherProperty (**data: Any)

Expand source code

class AdagentsPublisherProperty(RegistryBaseModel):
    publisher_domain: str | None = None
    publisher_domains: list[str] | None = None
    selection_type: PublisherPropertySelectionType
    property_ids: list[str] | None = None
    property_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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var property_ids : list[str] | None

var property_tags : list[str] | None

var publisher_domain : str | None

var publisher_domains : list[str] | None

var selection_type : PublisherPropertySelectionType

class AdagentsValidationIssue (**data: Any)

Expand source code

class AdagentsValidationIssue(RegistryBaseModel):
    field: str
    message: str
    severity: AdagentsValidationSeverity

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var field : str

var message : str

var model_config

var severity : AdagentsValidationSeverity

class AdagentsValidationResult (**data: Any)

Expand source code

class AdagentsValidationResult(RegistryBaseModel):
    valid: bool
    errors: list[AdagentsValidationIssue]
    warnings: list[AdagentsValidationWarning]
    domain: str
    url: str
    status_code: int | None = None
    response_bytes: Annotated[int | None, Field(ge=0)] = None
    resolved_url: str | None = None
    raw_data: Any | None = None
    discovery_method: AdagentsDiscoveryMethod
    manager_domain: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var discovery_method : AdagentsDiscoveryMethod

var domain : str

var errors : list[AdagentsValidationIssue]

var manager_domain : str | None

var model_config

var raw_data : typing.Any | None

var resolved_url : str | None

var response_bytes : int | None

var status_code : int | None

var url : str

var valid : bool

var warnings : list[AdagentsValidationWarning]

class AdagentsValidationSeverity (*args, **kwds)

Expand source code

class AdagentsValidationSeverity(Enum):
    error = "error"

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 error

class AdagentsValidationWarning (**data: Any)

Expand source code

class AdagentsValidationWarning(RegistryBaseModel):
    field: str
    message: str
    suggestion: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var field : str

var message : str

var model_config

var suggestion : str | None

class Agent (**data: Any)

Expand source code

class Agent(RegistryBaseModel):
    url: str
    name: str
    type: AgentType
    authorized_by: list[AuthorizedByItem]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_by : list[AuthorizedByItem]

var model_config

var name : str

var type : AgentType

var url : str

class Agent1 (**data: Any)

Expand source code

class Agent1(RegistryBaseModel):
    interaction_model: str
    examples: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var examples : list[str] | None

var interaction_model : str

var model_config

class AgentAuthStatus (**data: Any)

Expand source code

class AgentAuthStatus(RegistryBaseModel):
    has_auth: bool
    agent_context_id: str | None
    auth_type: AuthType | None
    has_oauth_token: bool
    has_valid_oauth: bool
    oauth_token_expires_at: str | None
    has_oauth_client_credentials: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_context_id : str | None

var auth_type : AuthType | None

var has_auth : bool

var has_oauth_client_credentials : bool

var has_oauth_token : bool

var has_valid_oauth : bool

var model_config

var oauth_token_expires_at : 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
    signals_capabilities: SignalsCapabilities | None = None
    measurement_capabilities: Annotated[
        MeasurementCapabilities | None,
        Field(
            description="Vendor-published per-metric catalog for measurement agents. Populated when the crawler successfully fetched and validated `get_adcp_capabilities.measurement` (AdCP 3.x). Mirrors the protocol shape — see the AdCP `get_adcp_capabilities` reference for field semantics."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var creative_capabilities : AgentCreativeCapabilities | None

var measurement_capabilities : MeasurementCapabilities | None

var model_config

var signals_capabilities : SignalsCapabilities | None

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
    requested_compliance_target: Annotated[
        str | None,
        Field(
            description="Requested compliance target before alias resolution, e.g. 3.0 or 3.1-beta."
        ),
    ] = None
    adcp_version: Annotated[
        str | None,
        Field(
            description="Concrete AdCP compliance bundle version used for the latest run, e.g. 3.0.12."
        ),
    ] = None
    lifecycle_stage: AgentLifecycleStage
    tracks: Annotated[dict[str, str], Field(examples=[{"core": "pass", "products": "fail"}])]
    track_details: Annotated[
        list[TrackDetail] | None,
        Field(
            description="Latest-run per-track summary. Skipped tracks with has_coverage_gap_skip=true represent selected coverage gaps, such as missing_test_controller."
        ),
    ] = None
    streak_days: int
    last_checked_at: str | None
    headline: str | None
    monitoring_paused: bool | None = None
    check_interval_hours: int | None = None
    verified: bool | None = None
    verified_roles: Annotated[
        list[VerifiedRole] | None,
        Field(
            description="AdCP protocols the agent is AAO Verified for (e.g. media-buy, creative). Matches enums/adcp-protocol.json."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var check_interval_hours : int | None

var headline : str | None

var last_checked_at : str | None

var lifecycle_stage : AgentLifecycleStage

var model_config

var monitoring_paused : bool | None

var requested_compliance_target : str | None

var status : ComplianceStatus

var streak_days : int

var track_details : list[TrackDetail] | None

var tracks : dict[str, str]

var verified : bool | None

var verified_roles : list[VerifiedRole] | None

class AgentComplianceDetail (**data: Any)

Expand source code

class AgentComplianceDetail(RegistryBaseModel):
    agent_url: str
    requested_compliance_target: Annotated[
        str | None,
        Field(
            description="Requested compliance target before alias resolution, e.g. 3.0 or 3.1-beta. Null for legacy rows before target recording."
        ),
    ] = None
    adcp_version: Annotated[
        str | None,
        Field(
            description="Concrete AdCP compliance bundle version used for the latest run, e.g. 3.0.12. Null for legacy rows before version recording."
        ),
    ] = None
    status: Status3
    lifecycle_stage: AgentLifecycleStage
    compliance_opt_out: bool | None = None
    tracks: dict[str, str] | None = None
    track_details: Annotated[
        list[TrackDetail] | None,
        Field(
            description="Latest-run per-track summary. Skipped tracks with has_coverage_gap_skip=true represent selected coverage gaps, such as missing_test_controller."
        ),
    ] = None
    streak_days: int | None = None
    last_checked_at: str | None = None
    last_passed_at: str | None = None
    last_failed_at: str | None = None
    headline: str | None = None
    status_changed_at: str | None = None
    storyboards_passing: int | None = None
    storyboards_total: int | None = None
    check_interval_hours: Annotated[
        int | None,
        Field(description="How often the heartbeat re-tests this agent, in hours"),
    ] = None
    declared_specialisms: Annotated[
        list[str] | None,
        Field(
            description="Specialisms the agent declared in get_adcp_capabilities, from the latest run"
        ),
    ] = None
    specialism_status: Annotated[
        dict[str, SpecialismStatus] | None,
        Field(
            description="Per-specialism pass/fail/untested status — keyed on declared specialism, derived from the matching storyboard's status"
        ),
    ] = None
    storyboard_statuses: Annotated[
        list[StoryboardStatus] | None,
        Field(
            description="Owner-scoped per-storyboard diagnostics used by the dashboard. Empty for non-owners."
        ),
    ] = None
    notices: Annotated[
        list[Any] | None,
        Field(
            description="Run-summary notices from the latest non-dry-run compliance run. Unknown codes/severities are preserved verbatim."
        ),
    ] = None
    observations: Annotated[
        list[Observation] | None,
        Field(
            description="Public-safe advisory observations from the latest non-dry-run compliance run. Raw evidence is intentionally omitted; this array is not merged across runs, so cleared advisories disappear on the next fresh run."
        ),
    ] = None
    membership_tier: Annotated[
        str | None,
        Field(
            description="Owner-scoped: the agent owner's membership tier. Populated only when the authenticated viewer owns the agent; null otherwise. Field is always present so response shape doesn't reveal ownership."
        ),
    ] = None
    membership_tier_label: Annotated[
        str | None,
        Field(
            description="Owner-scoped: human-readable label for membership_tier (e.g. 'Builder'). Null for non-owners."
        ),
    ] = None
    subscription_status: Annotated[
        str | None,
        Field(
            description="Owner-scoped: the agent owner's subscription status (active, past_due, trialing, etc.). Null for non-owners."
        ),
    ] = None
    is_api_access_tier: Annotated[
        bool | None,
        Field(
            description="Owner-scoped: true when the owner's tier and subscription status grant badge eligibility. False for non-owners. Single source of truth — UI should not re-derive."
        ),
    ] = None
    verdict_source: Annotated[
        VerdictSource | None,
        Field(
            description="Owner-scoped: triggered_by value of the most recent non-dry-run compliance check. Null for non-owners and when no run has been recorded. Operators use this as a UX cue ('did this verdict come from my recent test or the system heartbeat?')."
        ),
    ] = None
    verified: bool | None = None
    verified_badges: list[VerificationBadge] | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var agent_url : str

var check_interval_hours : int | None

var compliance_opt_out : bool | None

var declared_specialisms : list[str] | None

var headline : str | None

var is_api_access_tier : bool | None

var last_checked_at : str | None

var last_failed_at : str | None

var last_passed_at : str | None

var lifecycle_stage : AgentLifecycleStage

var membership_tier : str | None

var membership_tier_label : str | None

var model_config

var notices : list[typing.Any] | None

var observations : list[Observation] | None

var requested_compliance_target : str | None

var specialism_status : dict[str, SpecialismStatus] | None

var status : Status3

var status_changed_at : str | None

var storyboard_statuses : list[StoryboardStatus] | None

var storyboards_passing : int | None

var storyboards_total : int | None

var streak_days : int | None

var subscription_status : str | None

var track_details : list[TrackDetail] | None

var tracks : dict[str, str] | None

var verdict_source : VerdictSource | None

var verified : bool | None

var verified_badges : list[VerificationBadge] | None

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var email : str

var model_config

var name : str

var website : str

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

• RegistryBaseModel
• pydantic.main.BaseModel

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
    membership_tier: Annotated[
        str | None,
        Field(
            description="Raw AAO membership tier enum (e.g. `individual_professional`, `company_leader`). Present only when the profile owner has set their member card to public (`is_public=true`) AND the org has a resolvable tier. Absent for private profiles and for orgs without an active tier-bearing subscription."
        ),
    ] = None
    membership_tier_label: Annotated[
        str | None,
        Field(
            description="Human-readable label for `membership_tier` (e.g. `Professional`, `Partner`, `Leader`). Matches the AAO pricing page. Use this for UI display; the raw enum is for programmatic gating. Presence rules match `membership_tier`."
        ),
    ] = None
    is_founding_member: Annotated[
        bool | None,
        Field(
            description="True when the profile owner carries the Founding Member badge (joined before the founding-cohort cutoff). Surfaced when the profile owner has set their member card to public (`is_public=true`). Absent for private profiles. Founding Member is orthogonal to tier — founding orgs typically display both (e.g. Scope3 shows `Partner` + `Founding Member`)."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var display_name : str | None

var is_founding_member : bool | None

var membership_tier : str | None

var membership_tier_label : 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):
    adagents_json = "adagents_json"
    agent_claim = "agent_claim"

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 agent_claim

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var description : str

var model_config

var name : str

class AgentType (*args, **kwds)

Expand source code

class AgentType(Enum):
    brand = "brand"
    rights = "rights"
    measurement = "measurement"
    governance = "governance"
    creative = "creative"
    sales = "sales"
    buying = "buying"
    signals = "signals"
    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 brand

var buying

var creative

var governance

var measurement

var rights

var sales

var signals

var unknown

class AgentVerification (**data: Any)

Expand source code

class AgentVerification(RegistryBaseModel):
    agent_url: str
    verified: bool
    badges: list[VerificationBadge]
    registry_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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_url : str

var badges : list[VerificationBadge]

var model_config

var registry_url : str | None

var verified : bool

class Applied (*args, **kwds)

Expand source code

class Applied(Enum):
    members_only = "members_only"

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 members_only

class AuthType (*args, **kwds)

Expand source code

class AuthType(Enum):
    bearer = "bearer"
    basic = "basic"
    oauth = "oauth"
    oauth_client_credentials = "oauth_client_credentials"
    NoneType_None = None

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 NoneType_None

var basic

var bearer

var oauth

var oauth_client_credentials

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_for : str | None

var model_config

var url : str

class AuthorizedAgent2 (**data: Any)

Expand source code

class AuthorizedAgent2(RegistryBaseModel):
    url: str
    authorized_for: str | None = None
    source: Annotated[
        Source6,
        Field(
            description="How strongly this authorization is attested. `adagents_json`: the publisher's origin actually serves a valid adagents.json (origin-verified). `aao_hosted`: AAO is hosting the canonical document on the publisher's behalf — represents publisher intent but origin has NOT been verified to redirect to AAO. `agent_claim`: the agent claimed it; publisher has not confirmed."
        ),
    ]
    properties_authorized: Annotated[
        int | None,
        Field(
            description="Count of this publisher's properties the agent is authorized to sell. Absent when `rollup_truncated` is set (call `/api/registry/publisher/authorization` for the per-agent count) or when properties are entirely brand.json-hydrated (no adagents.json claim has actually been made about them).",
            ge=0,
        ),
    ] = None
    properties_total: Annotated[
        int | None,
        Field(
            description="Total number of properties this publisher exposes through the registry. Same value across all agents in the response. Absent when `properties_authorized` is absent.",
            ge=0,
        ),
    ] = None
    publisher_wide: Annotated[
        bool | None,
        Field(
            description="True when the agent has only a publisher-wide authorization row and `properties_authorized` was synthesized as `properties_total`. False when the agent has property-level authorization rows. Absent when the rollup is absent."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_for : str | None

var model_config

var properties_authorized : int | None

var properties_total : int | None

var publisher_wide : bool | None

var source : Source6

var url : str

class AuthorizedByItem (**data: Any)

Expand source code

class AuthorizedByItem(RegistryBaseModel):
    publisher_domain: str
    authorized_for: str | None = None
    source: AgentSource

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_for : str | None

var model_config

var publisher_domain : str

var source : AgentSource

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var domain : str

var model_config

var revisions : list[ActivityRevision]

var total : int

class BrandJson (**data: Any)

Expand source code

class BrandJson(RegistryBaseModel):
    status: Annotated[
        Status2,
        Field(
            description="What we know about the publisher's brand.json. `present` = a brand record with manifest data exists. `unknown` = no record yet. `checking` = an auto-crawl was kicked off."
        ),
    ]
    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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var name : str | None

var status : Status2

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 BrandSummary (**data: Any)

Expand source code

class BrandSummary(RegistryBaseModel):
    name: Annotated[
        str | None,
        Field(description="Display name from brand.json or the registered brand row."),
    ] = None
    description: Annotated[
        str | None,
        Field(description="Short brand or house description when present in brand.json."),
    ] = None
    logo_url: Annotated[str | None, Field(description="First usable logo URL from brand.json.")] = (
        None
    )
    colors: Annotated[
        list[str] | None,
        Field(description="Representative hex colors from brand.json, capped for display."),
    ] = None
    industries: Annotated[
        list[str] | None,
        Field(description="Industry labels from brand.json when present."),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var colors : list[str] | None

var description : str | None

var industries : list[str] | None

var logo_url : str | None

var model_config

var name : str | None

class Code (*args, **kwds)

Expand source code

class Code(Enum):
    invalid_blob_shape = "invalid_blob_shape"
    missing_field = "missing_field"
    invalid_field_type = "invalid_field_type"
    field_too_long = "field_too_long"
    invalid_url = "invalid_url"
    invalid_env_reference = "invalid_env_reference"
    invalid_auth_method_value = "invalid_auth_method_value"

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 field_too_long

var invalid_auth_method_value

var invalid_blob_shape

var invalid_env_reference

var invalid_field_type

var invalid_url

var missing_field

class Code1 (*args, **kwds)

Expand source code

class Code1(Enum):
    visibility_downgraded = "visibility_downgraded"

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 visibility_downgraded

class CollectionRef (**data: Any)

Expand source code

class CollectionRef(RegistryBaseModel):
    publisher_domain: str
    collection_ids: list[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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var collection_ids : list[str]

var model_config

var publisher_domain : str

class CommunityMirrorAdagentsJson (**data: Any)

Expand source code

class CommunityMirrorAdagentsJson(RegistryBaseModel):
    field_schema: Annotated[AnyUrl | None, Field(alias="$schema")] = None
    authorized_agents: Annotated[
        list[AdagentsAuthorizedAgent],
        Field(
            description="Always empty for community mirrors; these catalogs never assert sales authorization.",
            max_length=0,
        ),
    ]
    properties: list[dict[str, Any]] | None = None
    catalog_etag: str | None = None
    formats: list[dict[str, Any]] | None = None
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Clients should re-fetch the successor and update cached mirror references before retiring use of this mirror.",
            pattern="^https:\\/\\/",
        ),
    ] = None
    last_updated: AwareDatetime | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_agents : list[AdagentsAuthorizedAgent]

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var field_schema : pydantic.networks.AnyUrl | None

var formats : list[dict[str, typing.Any]] | None

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : str | None

class CommunityMirrorCatalogDocument (**data: Any)

Expand source code

class CommunityMirrorCatalogDocument(RegistryBaseModel):
    field_schema: Annotated[AnyUrl | None, Field(alias="$schema")] = None
    authorized_agents: list[AdagentsAuthorizedAgent]
    properties: list[dict[str, Any]] | None = None
    catalog_etag: str | None = None
    formats: list[dict[str, Any]] | None = None
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        AnyUrl | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Clients should re-fetch the successor and update cached mirror references before retiring use of this mirror."
        ),
    ] = None
    last_updated: AwareDatetime | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_agents : list[AdagentsAuthorizedAgent]

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var field_schema : pydantic.networks.AnyUrl | None

var formats : list[dict[str, typing.Any]] | None

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : pydantic.networks.AnyUrl | None

class CommunityMirrorDeleteResponse (**data: Any)

Expand source code

class CommunityMirrorDeleteResponse(RegistryBaseModel):
    success: SuccessLiteral
    platform: Annotated[
        str,
        Field(
            description="Lowercase platform identifier, normalized by the service.",
            examples=["example_platform"],
            pattern="^[a-z0-9_-]{1,64}$",
        ),
    ]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var platform : str

var success : SuccessLiteral

class CommunityMirrorGetResponse (**data: Any)

Expand source code

class CommunityMirrorGetResponse(RegistryBaseModel):
    platform: Annotated[
        str,
        Field(
            description="Lowercase platform identifier, normalized by the service.",
            examples=["example_platform"],
            pattern="^[a-z0-9_-]{1,64}$",
        ),
    ]
    catalog_etag: str | None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS successor document URL, when this mirror has been superseded.",
            pattern="^https:\\/\\/",
        ),
    ]
    adagents_json: CommunityMirrorAdagentsJson
    created_at: AwareDatetime
    updated_at: AwareDatetime

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adagents_json : CommunityMirrorAdagentsJson

var catalog_etag : str | None

var created_at : pydantic.types.AwareDatetime

var model_config

var platform : str

var superseded_by : str | None

var updated_at : pydantic.types.AwareDatetime

class CommunityMirrorListResponse (**data: Any)

Expand source code

class CommunityMirrorListResponse(RegistryBaseModel):
    mirrors: list[CommunityMirrorSummary]
    total: Annotated[int, Field(ge=0)]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var mirrors : list[CommunityMirrorSummary]

var model_config

var total : int

class CommunityMirrorPublishCollectionsRequest (**data: Any)

Expand source code

class CommunityMirrorPublishCollectionsRequest(RegistryBaseModel):
    catalog_etag: Annotated[str | None, Field(max_length=255, min_length=1)] = None
    formats: list[dict[str, Any]] | None = None
    properties: list[dict[str, Any]] | None = None
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: Annotated[list[dict[str, Any]], Field(min_length=1)]
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Set this before deleting a mirror so buyers can migrate cached references.",
            pattern="^https:\\/\\/",
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]]

var contact : typing.Any | None

var formats : list[dict[str, typing.Any]] | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : str | None

class CommunityMirrorPublishError (**data: Any)

Expand source code

class CommunityMirrorPublishError(RegistryBaseModel):
    error: str
    details: Annotated[
        list[Any] | None,
        Field(
            description="Validation details for request-body parse failures or adagents.json conformance errors."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var details : list[typing.Any] | None

var error : str

var model_config

class CommunityMirrorPublishFormatsRequest (**data: Any)

Expand source code

class CommunityMirrorPublishFormatsRequest(RegistryBaseModel):
    catalog_etag: Annotated[str | None, Field(max_length=255, min_length=1)] = None
    formats: Annotated[list[dict[str, Any]], Field(min_length=1)]
    properties: list[dict[str, Any]] | None = None
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Set this before deleting a mirror so buyers can migrate cached references.",
            pattern="^https:\\/\\/",
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var formats : list[dict[str, typing.Any]]

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : str | None

class CommunityMirrorPublishPlacementsRequest (**data: Any)

Expand source code

class CommunityMirrorPublishPlacementsRequest(RegistryBaseModel):
    catalog_etag: Annotated[str | None, Field(max_length=255, min_length=1)] = None
    formats: list[dict[str, Any]] | None = None
    properties: list[dict[str, Any]] | None = None
    placements: Annotated[list[dict[str, Any]], Field(min_length=1)]
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Set this before deleting a mirror so buyers can migrate cached references.",
            pattern="^https:\\/\\/",
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var formats : list[dict[str, typing.Any]] | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]]

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : str | None

class CommunityMirrorPublishPropertiesRequest (**data: Any)

Expand source code

class CommunityMirrorPublishPropertiesRequest(RegistryBaseModel):
    catalog_etag: Annotated[str | None, Field(max_length=255, min_length=1)] = None
    formats: list[dict[str, Any]] | None = None
    properties: Annotated[list[dict[str, Any]], Field(min_length=1)]
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: list[dict[str, Any]] | None = None
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Set this before deleting a mirror so buyers can migrate cached references.",
            pattern="^https:\\/\\/",
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var formats : list[dict[str, typing.Any]] | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]]

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]] | None

var superseded_by : str | None

class CommunityMirrorPublishRequest (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class CommunityMirrorPublishRequest(
    RootModel[
        CommunityMirrorPublishFormatsRequest
        | CommunityMirrorPublishPropertiesRequest
        | CommunityMirrorPublishPlacementsRequest
        | CommunityMirrorPublishCollectionsRequest
        | CommunityMirrorPublishSignalsRequest
    ]
):
    root: Annotated[
        CommunityMirrorPublishFormatsRequest
        | CommunityMirrorPublishPropertiesRequest
        | CommunityMirrorPublishPlacementsRequest
        | CommunityMirrorPublishCollectionsRequest
        | CommunityMirrorPublishSignalsRequest,
        Field(
            description="Catalog-only adagents.json body for a community mirror. At least one of `formats`, `properties`, `placements`, `collections`, or `signals` must be present and non-empty. The service regenerates `$schema` and `last_updated` before persisting."
        ),
    ]

Usage Documentation

RootModel and Custom Root Types

A Pydantic BaseModel for the root object of the model.

Attributes

root

The root object of the model.

__pydantic_root_model__

Whether the model is a RootModel.

__pydantic_private__

Private fields in the model.

__pydantic_extra__

Extra fields in the model.

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

• pydantic.root_model.RootModel[Union[CommunityMirrorPublishFormatsRequest, CommunityMirrorPublishPropertiesRequest, CommunityMirrorPublishPlacementsRequest, CommunityMirrorPublishCollectionsRequest, CommunityMirrorPublishSignalsRequest]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var root : CommunityMirrorPublishFormatsRequest | CommunityMirrorPublishPropertiesRequest | CommunityMirrorPublishPlacementsRequest | CommunityMirrorPublishCollectionsRequest | CommunityMirrorPublishSignalsRequest

class CommunityMirrorPublishResponse (**data: Any)

Expand source code

class CommunityMirrorPublishResponse(RegistryBaseModel):
    success: SuccessLiteral
    platform: Annotated[
        str,
        Field(
            description="Lowercase platform identifier, normalized by the service.",
            examples=["example_platform"],
            pattern="^[a-z0-9_-]{1,64}$",
        ),
    ]
    catalog_etag: str | None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS successor document URL, when this mirror has been superseded.",
            pattern="^https:\\/\\/",
        ),
    ]
    publisher_domains: Annotated[
        list[str],
        Field(description="Publisher domains updated from this community mirror catalog."),
    ]
    updated_at: AwareDatetime

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var model_config

var platform : str

var publisher_domains : list[str]

var success : SuccessLiteral

var superseded_by : str | None

var updated_at : pydantic.types.AwareDatetime

class CommunityMirrorPublishSignalsRequest (**data: Any)

Expand source code

class CommunityMirrorPublishSignalsRequest(RegistryBaseModel):
    catalog_etag: Annotated[str | None, Field(max_length=255, min_length=1)] = None
    formats: list[dict[str, Any]] | None = None
    properties: list[dict[str, Any]] | None = None
    placements: list[dict[str, Any]] | None = None
    placement_tags: dict[str, Any] | None = None
    collections: list[dict[str, Any]] | None = None
    signals: Annotated[list[dict[str, Any]], Field(min_length=1)]
    signal_tags: dict[str, Any] | None = None
    contact: Any | None = None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS URL for the canonical successor adagents.json document. Set this before deleting a mirror so buyers can migrate cached references.",
            pattern="^https:\\/\\/",
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var collections : list[dict[str, typing.Any]] | None

var contact : typing.Any | None

var formats : list[dict[str, typing.Any]] | None

var model_config

var placement_tags : dict[str, typing.Any] | None

var placements : list[dict[str, typing.Any]] | None

var properties : list[dict[str, typing.Any]] | None

var signal_tags : dict[str, typing.Any] | None

var signals : list[dict[str, typing.Any]]

var superseded_by : str | None

class CommunityMirrorSummary (**data: Any)

Expand source code

class CommunityMirrorSummary(RegistryBaseModel):
    platform: Annotated[
        str,
        Field(
            description="Lowercase platform identifier, normalized by the service.",
            examples=["example_platform"],
            pattern="^[a-z0-9_-]{1,64}$",
        ),
    ]
    catalog_etag: str | None
    superseded_by: Annotated[
        str | None,
        Field(
            description="HTTPS successor document URL, when this mirror has been superseded.",
            pattern="^https:\\/\\/",
        ),
    ]
    updated_at: AwareDatetime

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var catalog_etag : str | None

var model_config

var platform : str

var superseded_by : str | None

var updated_at : pydantic.types.AwareDatetime

class CompanySearchResult (**data: Any)

Expand source code

class CompanySearchResult(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["coca-cola.com"])]
    canonical_domain: Annotated[str, Field(examples=["coca-cola.com"])]
    brand_name: Annotated[str, Field(examples=["The Coca-Cola Company"])]
    house_domain: Annotated[str | None, Field(examples=["coca-cola.com"])] = None
    keller_type: KellerType | None = None
    parent_brand: str | None = None
    brand_agent_url: str | None = None
    source: Annotated[str, Field(examples=["community"])]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var brand_agent_url : str | None

var brand_name : str

var canonical_domain : str

var domain : str

var house_domain : str | None

var keller_type : KellerType | None

var model_config

var parent_brand : str | None

var source : str

class ComplianceRun (**data: Any)

Expand source code

class ComplianceRun(RegistryBaseModel):
    id: str
    requested_compliance_target: str | None = None
    adcp_version: str | None = None
    overall_status: str
    headline: str | None
    tracks_passed: int
    tracks_failed: int
    tracks_skipped: int
    tracks_partial: int
    tracks_json: Any | None = None
    total_duration_ms: float | None
    triggered_by: str
    tested_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var headline : str | None

var id : str

var model_config

var overall_status : str

var requested_compliance_target : str | None

var tested_at : str

var total_duration_ms : float | None

var tracks_failed : int

var tracks_json : typing.Any | None

var tracks_partial : int

var tracks_passed : int

var tracks_skipped : int

var triggered_by : str

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 ComplianceStepDiagnostic (**data: Any)

Expand source code

class ComplianceStepDiagnostic(RegistryBaseModel):
    id: float | str
    run_id: str
    agent_url: str
    storyboard_id: str
    phase_id: str
    step_id: str
    task: str
    step_passed: bool
    duration_ms: float | None = None
    request_url: str | None = None
    request_jsonb: Any | None = None
    response_status: float | None = None
    response_headers_jsonb: dict[str, Any] | None = None
    response_jsonb: Any | None = None
    extraction_path: str | None = None
    extraction_note: str | None = None
    error_text: str | None = None
    adcp_error_jsonb: Any | None = None
    failed_validations_jsonb: Any | None = None
    served_by_agent_url: str | None = None
    captured_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error_jsonb : typing.Any | None

var agent_url : str

var captured_at : str

var duration_ms : float | None

var error_text : str | None

var extraction_note : str | None

var extraction_path : str | None

var failed_validations_jsonb : typing.Any | None

var id : float | str

var model_config

var phase_id : str

var request_jsonb : typing.Any | None

var request_url : str | None

var response_headers_jsonb : dict[str, typing.Any] | None

var response_jsonb : typing.Any | None

var response_status : float | None

var run_id : str

var served_by_agent_url : str | None

var step_id : str

var step_passed : bool

var storyboard_id : str

var task : str

class CreateAdagentsData (**data: Any)

Expand source code

class CreateAdagentsData(RegistryBaseModel):
    success: SuccessLiteral
    adagents_json: Annotated[
        str,
        Field(description="Pretty-printed adagents.json document generated by the service."),
    ]
    validation: AdagentsValidationResult

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adagents_json : str

var model_config

var success : SuccessLiteral

var validation : AdagentsValidationResult

class CreateAdagentsResponse (**data: Any)

Expand source code

class CreateAdagentsResponse(RegistryBaseModel):
    success: SuccessLiteral
    data: CreateAdagentsData
    timestamp: AwareDatetime

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var data : CreateAdagentsData

var model_config

var success : SuccessLiteral

var timestamp : pydantic.types.AwareDatetime

class CreateOrganizationInput (**data: Any)

Expand source code

class CreateOrganizationInput(RegistryBaseModel):
    organization_name: Annotated[
        str,
        Field(
            description="Display name for the organization. Used both as the org row name and (when auto-bootstrapping a member profile via the first agent registration) as the profile's `display_name`.",
            examples=["Acme Media"],
            max_length=200,
            min_length=1,
        ),
    ]
    is_personal: Annotated[
        bool | None,
        Field(
            description="Set to `true` to create a personal workspace instead of a corporate organization. Personal workspaces skip corporate-domain verification, are limited to one per user, and cannot host the `company_*` membership tiers."
        ),
    ] = False
    company_type: OrganizationCompanyType | None = None
    revenue_tier: OrganizationRevenueTier | None = None
    marketing_opt_in: Annotated[
        bool | None,
        Field(
            description="Whether the caller opted in to AAO marketing communications. Recorded once per user (not overwritten on subsequent calls). Independent of Terms-of-Service consent, which is recorded server-side from the request context."
        ),
    ] = False

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var company_type : OrganizationCompanyType | None

var is_personal : bool | None

var marketing_opt_in : bool | None

var model_config

var organization_name : str

var revenue_tier : OrganizationRevenueTier | None

class CreateOrganizationResponse (**data: Any)

Expand source code

class CreateOrganizationResponse(RegistryBaseModel):
    success: bool | None = None
    organization: Organization | None = None
    id: Annotated[
        str | None,
        Field(
            description="Set on the **prospect-adoption** path: when an org with the user's email domain already exists in a `prospect` state (i.e. the registry pre-recorded it from a brand crawl but no human had claimed it yet), this call adopts that org for the caller instead of creating a new one."
        ),
    ] = None
    name: str | None = None
    adopted: Annotated[
        bool | None,
        Field(
            description="`true` when the response is the prospect-adoption path. When `true`, no new WorkOS organization was created — the caller is now the owner of an existing prospect record."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adopted : bool | None

var id : str | None

var model_config

var name : str | None

var organization : Organization | None

var success : bool | None

class CredentialSaveValidationError (**data: Any)

Expand source code

class CredentialSaveValidationError(RegistryBaseModel):
    error: str
    code: Annotated[
        Code,
        Field(description="Stable rejection tag. UI maps this to operator-friendly prose."),
    ]
    field: Annotated[FieldModel, Field(description="Field the UI should scroll to + highlight.")]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var code : Code

var error : str

var field : FieldModel

var model_config

class DelegationType (*args, **kwds)

Expand source code

class DelegationType(Enum):
    direct = "direct"
    delegated = "delegated"
    ad_network = "ad_network"

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 ad_network

var delegated

var direct

class DiscoveryMethod (*args, **kwds)

Expand source code

class DiscoveryMethod(Enum):
    direct = "direct"
    authoritative_location = "authoritative_location"
    ads_txt_managerdomain = "ads_txt_managerdomain"
    adagents_authoritative = "adagents_authoritative"
    community_catalog = "community_catalog"
    NoneType_None = None

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 NoneType_None

var adagents_authoritative

var ads_txt_managerdomain

var authoritative_location

var community_catalog

var direct

class DomainAuthorizedAgent (**data: Any)

Expand source code

class DomainAuthorizedAgent(RegistryBaseModel):
    url: str
    authorized_for: str | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_for : str | None

var member : AgentMember | None

var model_config

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

• RegistryBaseModel
• pydantic.main.BaseModel

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
    member: Annotated[
        AgentMember | None,
        Field(
            description="AAO member that owns this agent record. The registry contains only agents that members have explicitly enrolled on their member profile."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var added_date : str | None

var capabilities : AgentCapabilities | None

var compliance : AgentCompliance | None

var contact : AgentDetailedContact | None

var description : str | 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 stats : AgentStats | None

var type : AgentType

var url : str

class FederatedPublisher (**data: Any)

Expand source code

class FederatedPublisher(RegistryBaseModel):
    domain: str
    member: AgentMember | None = None
    agent_count: int | None = None
    last_validated: str | None = None
    has_valid_adagents: bool | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_count : int | None

var domain : str

var has_valid_adagents : bool | None

var last_validated : str | None

var member : AgentMember | None

var model_config

class FeedEvent (**data: Any)

Expand source code

class FeedEvent(RegistryBaseModel):
    event_id: str
    event_type: str
    entity_type: str
    entity_id: str
    payload: dict[str, Any]
    actor: str
    created_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

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):
    events: list[FeedEvent]
    cursor: str | None
    has_more: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var cursor : str | None

var events : list[FeedEvent]

var has_more : bool

var model_config

class FieldModel (*args, **kwds)

Expand source code

class FieldModel(Enum):
    oauth_client_credentials = "oauth_client_credentials"
    token_endpoint = "token_endpoint"
    client_id = "client_id"
    client_secret = "client_secret"
    scope = "scope"
    resource = "resource"
    audience = "audience"
    auth_method = "auth_method"

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 audience

var auth_method

var client_id

var client_secret

var oauth_client_credentials

var resource

var scope

var token_endpoint

class Files (**data: Any)

Expand source code

class Files(RegistryBaseModel):
    adagents_json: AdagentsJson
    brand_json: BrandJson

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adagents_json : AdagentsJson

var brand_json : BrandJson

var model_config

class FindCompanyResult (**data: Any)

Expand source code

class FindCompanyResult(RegistryBaseModel):
    results: list[CompanySearchResult]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var results : list[CompanySearchResult]

class FormatSummary (**data: Any)

Expand source code

class FormatSummary(RegistryBaseModel):
    format_option_id: Annotated[
        str | None,
        Field(description="Stable format option identifier from adagents.json `formats[]`."),
    ] = None
    display_name: Annotated[
        str,
        Field(description="Human-readable format label for catalog and publisher UI display."),
    ]
    format_kind: Annotated[
        str,
        Field(
            description="Canonical format discriminator, such as `image`, `video_hosted`, `native_in_feed`, or `custom`."
        ),
    ]
    params: Annotated[
        dict[str, Any] | None,
        Field(
            description="Canonical format params from the publisher's adagents.json declaration."
        ),
    ] = None
    applies_to_property_ids: Annotated[
        list[str] | None,
        Field(
            description="ResolvedPropertyEntry IDs this format applies to; absent means all properties."
        ),
    ] = None
    applies_to_property_tags: Annotated[
        list[str] | None,
        Field(
            description="ResolvedPropertyEntry tags this format applies to; absent means all properties."
        ),
    ] = None
    seller_preference: Annotated[
        str | None,
        Field(description="Seller preference hint from the format declaration, when present."),
    ] = None
    experimental: Annotated[
        bool | None,
        Field(description="Whether this seller's format declaration is marked experimental."),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var applies_to_property_ids : list[str] | None

var applies_to_property_tags : list[str] | None

var display_name : str

var experimental : bool | None

var format_kind : str

var format_option_id : str | None

var model_config

var params : dict[str, typing.Any] | None

var seller_preference : str | None

class Hosting (**data: Any)

Expand source code

class Hosting(RegistryBaseModel):
    mode: Annotated[
        Mode,
        Field(
            description="Where this publisher's adagents.json lives. `self` = publisher hosts a valid file at their own /.well-known. `self_invalid` = publisher's /.well-known returns a file that fails validation (fixable misconfiguration, not absence). `aao_hosted` = the publisher hosts a stub at their own /.well-known whose `authoritative_location` points at AAO's canonical document. `self_redirected` = the publisher's stub `authoritative_location` resolves to a third-party HTTPS origin (a CDN, partner CMS, or sibling host) — verifiers should audit the TLS chain at `resolved_url`, not at the publisher's own origin. `none` = no adagents.json configured yet."
        ),
    ]
    hosted_url: Annotated[
        str | None,
        Field(
            description="Canonical AAO-hosted adagents.json URL. Present iff `mode === 'aao_hosted'`. Publishers reference this URL from their own /.well-known stub via the `authoritative_location` field (see https://docs.adcontextprotocol.org/docs/governance/property/adagents)."
        ),
    ] = None
    expected_url: Annotated[
        str,
        Field(
            description="Where adagents.json *should* live for this domain — the publisher's own /.well-known path. Always populated, regardless of `mode`."
        ),
    ]
    resolved_url: Annotated[
        str | None,
        Field(
            description="Where the canonical adagents.json document actually lives after following the publisher's `authoritative_location` stub or any HTTP-layer redirects. Populated when `mode === 'self_redirected'` (the third-party HTTPS origin verifiers should audit) and when `mode === 'aao_hosted'` AND the publisher has actively set up the redirect (`authoritative_location` in the manifest body or a network-layer redirect to AAO's hosted URL). NULL when there's no resolved-URL evidence to report."
        ),
    ] = None
    last_validated: Annotated[
        str | None,
        Field(
            description="ISO timestamp of the last successful validation crawl. Lets verifiers sanity-check freshness. NULL when never crawled."
        ),
    ] = None
    last_http_status: Annotated[
        int | None,
        Field(
            description="HTTP status code returned by AAO's most recent fetch attempt of the publisher's `/.well-known/adagents.json`. Verifier-grade chrome — lets a buy-side scraper confirm they see the same response AAO does. NULL until the first crawl records or for transient errors that never produced an HTTP response.",
            ge=100,
            le=599,
        ),
    ] = None
    last_bytes: Annotated[
        int | None,
        Field(
            description="Response body byte length from the most recent fetch (post-decompression). When `authoritative_location` was followed, measures the canonical document body, not the stub. NULL until the first crawl records.",
            ge=0,
        ),
    ] = None
    origin_verified_at: Annotated[
        str | None,
        Field(
            description="ISO timestamp of the last successful origin verification — AAO fetched the publisher's own /.well-known/adagents.json and confirmed `authoritative_location` points at our hosted URL. When set, the publisher's authorization rows have been promoted to `source='adagents_json'` (origin-attested). NULL when never verified or last attempt failed. Only populated when `mode === 'aao_hosted'`."
        ),
    ] = None
    origin_last_checked_at: Annotated[
        str | None,
        Field(
            description='ISO timestamp of the last verification attempt regardless of result. Lets a caller render "checked X minutes ago, not yet verified" vs "never checked." Only populated when `mode === \'aao_hosted\'`.'
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var expected_url : str

var hosted_url : str | None

var last_bytes : int | None

var last_http_status : int | None

var last_validated : str | None

var mode : Mode

var model_config

var origin_last_checked_at : str | None

var origin_verified_at : str | None

var resolved_url : str | None

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 MeasurementCapabilities (**data: Any)

Expand source code

class MeasurementCapabilities(RegistryBaseModel):
    metrics: list[Metric]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var metrics : list[Metric]

var model_config

class MemberAgent (**data: Any)

Expand source code

class MemberAgent(RegistryBaseModel):
    url: Annotated[AnyUrl, Field(examples=["https://agent.example.com/mcp"])]
    visibility: MemberAgentVisibility
    type: MemberAgentType
    name: str | None = None
    health_check_url: Annotated[
        AnyUrl | None,
        Field(
            description="Optional fallback liveness URL used by the health probe when the protocol handshake fails."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var health_check_url : pydantic.networks.AnyUrl | None

var model_config

var name : str | None

var type : MemberAgentType

var url : pydantic.networks.AnyUrl

var visibility : MemberAgentVisibility

class MemberAgentInput (**data: Any)

Expand source code

class MemberAgentInput(RegistryBaseModel):
    url: Annotated[AnyUrl, Field(examples=["https://agent.example.com/mcp"])]
    type: MemberAgentTypeInput
    name: str | None = None
    visibility: MemberAgentVisibility | None = None
    health_check_url: AnyUrl | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var health_check_url : pydantic.networks.AnyUrl | None

var model_config

var name : str | None

var type : MemberAgentTypeInput

var url : pydantic.networks.AnyUrl

var visibility : MemberAgentVisibility | None

class MemberAgentListResponse (**data: Any)

Expand source code

class MemberAgentListResponse(RegistryBaseModel):
    agents: list[MemberAgent]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agents : list[MemberAgent]

var model_config

class MemberAgentPatch (**data: Any)

Expand source code

class MemberAgentPatch(RegistryBaseModel):
    name: str | None = None
    visibility: MemberAgentVisibility | None = None
    type: MemberAgentTypeInput | None = None
    health_check_url: AnyUrl | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var health_check_url : pydantic.networks.AnyUrl | None

var model_config

var name : str | None

var type : MemberAgentTypeInput | None

var visibility : MemberAgentVisibility | None

class MemberAgentResponse (**data: Any)

Expand source code

class MemberAgentResponse(RegistryBaseModel):
    agent: MemberAgent
    warnings: list[MemberAgentVisibilityWarning] | None = None
    org_auto_created: Annotated[
        bool | None,
        Field(
            description="Set to `true` when this `POST` was the caller's first interaction with the registry and the server auto-created the organization (display name derived from the user's email domain for corporate emails, or `<First Last>'s Workspace` for free-email providers). Combined with `profile_auto_created`, this is the one-call storefront experience: a third-party app holding only an OAuth token gets the org, profile, and registered agent in a single request."
        ),
    ] = None
    profile_auto_created: Annotated[
        bool | None,
        Field(
            description='Set to `true` when this `POST` was the first agent registration on the caller\'s organization and the server auto-created a private member profile (display name = organization name, `is_public: false`). Absent on subsequent calls and on update-in-place. Surfaced so storefront-style integrations can show a "we set up your profile" hint without needing to detect the prior 404 → bootstrap → retry shape.'
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent : MemberAgent

var model_config

var org_auto_created : bool | None

var profile_auto_created : bool | None

var warnings : list[MemberAgentVisibilityWarning] | None

class MemberAgentType (*args, **kwds)

Expand source code

class MemberAgentType(Enum):
    brand = "brand"
    rights = "rights"
    measurement = "measurement"
    governance = "governance"
    creative = "creative"
    sales = "sales"
    buying = "buying"
    signals = "signals"
    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 brand

var buying

var creative

var governance

var measurement

var rights

var sales

var signals

var unknown

class MemberAgentTypeInput (*args, **kwds)

Expand source code

class MemberAgentTypeInput(Enum):
    brand = "brand"
    rights = "rights"
    measurement = "measurement"
    governance = "governance"
    creative = "creative"
    sales = "sales"
    buying = "buying"
    signals = "signals"

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

var buying

var creative

var governance

var measurement

var rights

var sales

var signals

class MemberAgentVisibility (*args, **kwds)

Expand source code

class MemberAgentVisibility(Enum):
    private = "private"
    members_only = "members_only"
    public = "public"

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 members_only

var private

var public

class MemberAgentVisibilityWarning (**data: Any)

Expand source code

class MemberAgentVisibilityWarning(RegistryBaseModel):
    code: Code1
    agent_url: str
    requested: Requested
    applied: Applied
    reason: Reason
    message: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_url : str

var applied : Applied

var code : Code1

var message : str

var model_config

var reason : Reason

var requested : Requested

class Metric (**data: Any)

Expand source code

class Metric(RegistryBaseModel):
    metric_id: str
    standard_reference: str | None = None
    accreditations: list[Accreditation] | None = None
    unit: str | None = None
    description: str | None = None
    methodology_url: str | None = None
    methodology_version: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var accreditations : list[Accreditation] | None

var description : str | None

var methodology_url : str | None

var methodology_version : str | None

var metric_id : str

var model_config

var standard_reference : str | None

var unit : str | None

class Mode (*args, **kwds)

Expand source code

class Mode(Enum):
    self = "self"
    self_invalid = "self_invalid"
    aao_hosted = "aao_hosted"
    self_redirected = "self_redirected"
    none = "none"

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 aao_hosted

var none

var self

var self_invalid

var self_redirected

class MonitoringSettings (**data: Any)

Expand source code

class MonitoringSettings(RegistryBaseModel):
    monitoring_paused: bool
    check_interval_hours: int
    monitoring_paused_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var check_interval_hours : int

var model_config

var monitoring_paused : bool

var monitoring_paused_at : str | None

class Observation (**data: Any)

Expand source code

class Observation(RegistryBaseModel):
    category: str
    severity: str
    message: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var category : str

var message : str

var model_config

var severity : str

class OperatorLookupResult (**data: Any)

Expand source code

class OperatorLookupResult(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["pubmatic.com"])]
    member: AgentMember | None
    agents: list[Agent]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agents : list[Agent]

var domain : str

var member : AgentMember | None

var model_config

class Organization (**data: Any)

Expand source code

class Organization(RegistryBaseModel):
    id: Annotated[str, Field(examples=["org_01HXZAB123"])]
    name: Annotated[str, Field(examples=["Acme Media"])]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var id : str

var model_config

var name : str

class OrganizationCompanyType (*args, **kwds)

Expand source code

class OrganizationCompanyType(Enum):
    adtech = "adtech"
    agency = "agency"
    brand = "brand"
    publisher = "publisher"
    data = "data"
    ai = "ai"
    other = "other"

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 adtech

var agency

var ai

var brand

var data

var other

var publisher

class OrganizationRevenueTier (*args, **kwds)

Expand source code

class OrganizationRevenueTier(Enum):
    under_1m = "under_1m"
    field_1m_5m = "1m_5m"
    field_5m_50m = "5m_50m"
    field_50m_250m = "50m_250m"
    field_250m_1b = "250m_1b"
    field_1b_plus = "1b_plus"

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 field_1b_plus

var field_1m_5m

var field_250m_1b

var field_50m_250m

var field_5m_50m

var under_1m

class OutboundRequest (**data: Any)

Expand source code

class OutboundRequest(RegistryBaseModel):
    id: str
    agent_url: str
    request_type: str
    user_agent: str
    response_time_ms: float | None
    success: bool
    error_message: str | None
    created_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_url : str

var created_at : str

var error_message : str | None

var id : str

var model_config

var request_type : str

var response_time_ms : float | None

var success : bool

var user_agent : str

class Phase (**data: Any)

Expand source code

class Phase(RegistryBaseModel):
    title: str
    steps: list[Step]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var steps : list[Step]

var title : str

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=[
                "CreateAdagentsData 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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 Property1 (**data: Any)

Expand source code

class Property1(RegistryBaseModel):
    id: str | None = None
    type: str | None = None
    name: str | None = None
    identifiers: list[PropertyIdentifier] | None = None
    tags: Annotated[
        list[str] | None,
        Field(
            description="Arbitrary string tags on this property. The `relationship:` prefix tag (e.g. `relationship:owned`) is deprecated in favour of the `delegation_type` field and will be removed in a future release."
        ),
    ] = None
    source: Annotated[
        Source5 | None,
        Field(
            description="Where this property came from. `adagents_json` comes from the publisher's own adagents.json, `community` from an approved community adagents.json catalog, `discovered` from crawler or third-party signals, and `brand_json` from the publisher's brand.json when no federated-index data exists yet."
        ),
    ] = None
    delegation_type: Annotated[
        DelegationType | None,
        Field(
            description="Delegation relationship declared in brand.json. Populated only when `source` is `brand_json` — for `adagents_json` and `discovered` sources the authoritative value is on the matching `authorized_agents` entry. Mirrors adagents.json `delegation_type` for bilateral verification: `direct` = publisher treats this as a direct buying path, even if a third party operates the software; `delegated` = a rep firm or manager is authorized to sell on the publisher's behalf (operator-declared, unilateral until corroborated by the publisher's adagents.json); `ad_network` = sold as part of a network/exchange package. `owned` properties have no `delegation_type` — ownership is implicit and has no adagents.json counterpart."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var delegation_type : DelegationType | None

var id : str | None

var identifiers : list[PropertyIdentifier] | None

var model_config

var name : str | None

var source : Source5 | None

var tags : list[str] | None

var type : str | None

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 PublisherLookupResult (**data: Any)

Expand source code

class PublisherLookupResult(RegistryBaseModel):
    domain: Annotated[str, Field(examples=["voxmedia.com"])]
    member: AgentMember | None
    adagents_valid: bool | None
    discovery_method: Annotated[
        DiscoveryMethod | None,
        Field(
            description="How the publisher's adagents.json was discovered on the most recent successful crawl or registry write. `direct`: publisher's own /.well-known/ served the document. `authoritative_location`: publisher's stub redirected to a canonical URL. `ads_txt_managerdomain`: manifest was discovered via ads.txt MANAGERDOMAIN delegation. `adagents_authoritative`: manager file named this publisher through publisher_properties fan-out. `community_catalog`: moderator-approved community catalog. Null until first crawl after migration 470."
        ),
    ] = None
    manager_domain: Annotated[
        str | None,
        Field(
            description="The manager domain whose adagents.json was used to authorize this publisher's agents. Non-null only when `discovery_method` is `ads_txt_managerdomain`. Matches the MANAGERDOMAIN value from the publisher's ads.txt."
        ),
    ] = None
    hosting: Hosting
    files: Annotated[
        Files | None,
        Field(
            description="Plain-English summary of what AAO has found at the publisher's origin. The publisher page leads with this — `you have a valid adagents.json` is the primary signal, not `mode === self`. Optional in the schema for backwards compatibility; the handler always populates it."
        ),
    ] = None
    properties: list[Property1]
    brand: Annotated[
        BrandSummary | None,
        Field(
            description="Display-oriented brand identity summary from brand.json. The full raw document remains available from the publisher's /.well-known/brand.json or hosted registry URL."
        ),
    ] = None
    formats: Annotated[
        list[FormatSummary] | None,
        Field(
            description="Display-oriented summary of top-level adagents.json `formats[]`, normalized for publisher pages and agent discovery clients. Each entry preserves `format_kind`, `format_option_id`, and canonical params."
        ),
    ] = None
    authorized_agents: list[AuthorizedAgent2]
    rollup_truncated: Annotated[
        RollupTruncated | None,
        Field(
            description="Set when the publisher has more authorized agents than the per-agent rollup cap. Above the cap, agents beyond `cap` are returned without `properties_authorized` / `properties_total` / `publisher_wide`; call `/api/registry/publisher/authorization?domain=X&agent=Y` for the per-agent count. Lets a caller decide whether to fan out individual calls or stop reading."
        ),
    ] = None
    auto_crawl_triggered: Annotated[
        bool | None,
        Field(
            description="Set to `true` when this request triggered a background crawl of the publisher's origin (we hadn't crawled before). The client should refetch in ~3-5s to pick up fresh data. Debounced per-domain so a tight refresh loop won't keep firing crawls."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adagents_valid : bool | None

var authorized_agents : list[AuthorizedAgent2]

var auto_crawl_triggered : bool | None

var brand : BrandSummary | None

var discovery_method : DiscoveryMethod | None

var domain : str

var files : Files | None

var formats : list[FormatSummary] | None

var hosting : Hosting

var manager_domain : str | None

var member : AgentMember | None

var model_config

var properties : list[Property1]

var rollup_truncated : RollupTruncated | None

class PublisherPropertySelectionType (*args, **kwds)

Expand source code

class PublisherPropertySelectionType(Enum):
    all = "all"
    by_id = "by_id"
    by_tag = "by_tag"

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 all

var by_id

var by_tag

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 RateLimitError (**data: Any)

Expand source code

class RateLimitError(RegistryBaseModel):
    error: str
    message: str | None = None
    retryAfter: Annotated[int | None, Field(description="Seconds to wait before retrying.")] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var error : str

var message : str | None

var model_config

var retryAfter : int | None

class Reason (*args, **kwds)

Expand source code

class Reason(Enum):
    tier_required = "tier_required"

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 tier_required

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var error : str

var model_config

class RegistryMetadata (**data: Any)

Expand source code

class RegistryMetadata(RegistryBaseModel):
    agent_url: str
    lifecycle_stage: AgentLifecycleStage
    compliance_opt_out: bool
    monitoring_paused: bool
    check_interval_hours: int
    monitoring_paused_at: str | None
    created_at: str
    updated_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent_url : str

var check_interval_hours : int

var compliance_opt_out : bool

var created_at : str

var lifecycle_stage : AgentLifecycleStage

var model_config

var monitoring_paused : bool

var monitoring_paused_at : str | None

var updated_at : str

class Requested (*args, **kwds)

Expand source code

class Requested(Enum):
    public = "public"

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 public

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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

• RegistryBaseModel
• pydantic.main.BaseModel

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 Role (*args, **kwds)

Expand source code

class Role(Enum):
    media_buy = "media-buy"
    signals = "signals"
    governance = "governance"
    creative = "creative"
    brand = "brand"
    sponsored_intelligence = "sponsored-intelligence"
    measurement = "measurement"

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

var creative

var governance

var measurement

var media_buy

var signals

var sponsored_intelligence

class RollupTruncated (**data: Any)

Expand source code

class RollupTruncated(RegistryBaseModel):
    cap: Annotated[
        int,
        Field(
            description="Maximum number of agents for which the rollup is computed in a single response.",
            gt=0,
        ),
    ]
    total_agents: Annotated[
        int,
        Field(
            description="Total authorized-agent count for this publisher (the full population the cap was applied to).",
            ge=0,
        ),
    ]

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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var cap : int

var model_config

var total_agents : int

class SalesAgentClaim (**data: Any)

Expand source code

class SalesAgentClaim(RegistryBaseModel):
    url: str
    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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var member : AgentMember | None

var model_config

var url : str

class SignalsCapabilities (**data: Any)

Expand source code

class SignalsCapabilities(RegistryBaseModel):
    audience_types: list[str]
    can_match: bool
    can_activate: bool
    can_get_signals: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var audience_types : list[str]

var can_activate : bool

var can_get_signals : bool

var can_match : bool

var model_config

class Source5 (*args, **kwds)

Expand source code

class Source5(Enum):
    adagents_json = "adagents_json"
    community = "community"
    discovered = "discovered"
    brand_json = "brand_json"

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 brand_json

var community

var discovered

class Source6 (*args, **kwds)

Expand source code

class Source6(Enum):
    adagents_json = "adagents_json"
    aao_hosted = "aao_hosted"
    agent_claim = "agent_claim"

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 aao_hosted

var adagents_json

var agent_claim

class SpecialismStatus (*args, **kwds)

Expand source code

class SpecialismStatus(Enum):
    passing = "passing"
    failing = "failing"
    untested = "untested"
    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 failing

var passing

var unknown

var untested

class Status1 (*args, **kwds)

Expand source code

class Status1(Enum):
    valid = "valid"
    community = "community"
    invalid = "invalid"
    unknown = "unknown"
    checking = "checking"

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 checking

var community

var invalid

var unknown

var valid

class Status2 (*args, **kwds)

Expand source code

class Status2(Enum):
    present = "present"
    unknown = "unknown"
    checking = "checking"

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 checking

var present

var unknown

class Status3 (*args, **kwds)

Expand source code

class Status3(Enum):
    passing = "passing"
    degraded = "degraded"
    failing = "failing"
    unknown = "unknown"
    opted_out = "opted_out"

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 opted_out

var passing

var unknown

class Status4 (*args, **kwds)

Expand source code

class Status4(Enum):
    passing = "passing"
    failing = "failing"
    partial = "partial"
    untested = "untested"

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 failing

var partial

var passing

var untested

class Step (**data: Any)

Expand source code

class Step(RegistryBaseModel):
    id: str
    title: str
    description: str
    expected_output: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var description : str

var expected_output : str

var id : str

var model_config

var title : str

class StoryboardDetail (**data: Any)

Expand source code

class StoryboardDetail(RegistryBaseModel):
    id: str
    title: str
    category: str
    summary: str
    agent: Agent1
    phases: list[Phase]
    prerequisites: Any | None = None
    required_tools: list[str] | None = None
    track: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var agent : Agent1

var category : str

var id : str

var model_config

var phases : list[Phase]

var prerequisites : typing.Any | None

var required_tools : list[str] | None

var summary : str

var title : str

var track : str | None

class StoryboardStatus (**data: Any)

Expand source code

class StoryboardStatus(RegistryBaseModel):
    storyboard_id: str
    requested_compliance_target: str | None = None
    adcp_version: str | None = None
    title: str
    category: str | None
    track: str | None
    status: Status4
    steps_passed: int
    steps_total: int
    last_tested_at: str | None
    last_passed_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var category : str | None

var last_passed_at : str | None

var last_tested_at : str | None

var model_config

var requested_compliance_target : str | None

var status : Status4

var steps_passed : int

var steps_total : int

var storyboard_id : str

var title : str

var track : str | None

class StoryboardStatus1 (**data: Any)

Expand source code

class StoryboardStatus1(RegistryBaseModel):
    storyboard_id: str
    requested_compliance_target: Annotated[
        str | None,
        Field(
            description="Requested compliance target from the run that produced this storyboard verdict, e.g. 3.0 or 3.1-beta."
        ),
    ] = None
    adcp_version: Annotated[
        str | None,
        Field(
            description="Concrete AdCP compliance bundle version from the run that produced this storyboard verdict."
        ),
    ] = None
    title: str
    category: str | None
    track: str | None
    status: Status4
    steps_passed: int
    steps_total: int
    last_tested_at: str | None
    last_passed_at: 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var category : str | None

var last_passed_at : str | None

var last_tested_at : str | None

var model_config

var requested_compliance_target : str | None

var status : Status4

var steps_passed : int

var steps_total : int

var storyboard_id : str

var title : str

var track : str | None

class StoryboardSummary (**data: Any)

Expand source code

class StoryboardSummary(RegistryBaseModel):
    id: str
    title: str
    category: str
    summary: str
    interaction_model: str
    examples: list[str]
    phase_count: int
    step_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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var category : str

var examples : list[str]

var id : str

var interaction_model : str

var model_config

var phase_count : int

var step_count : int

var summary : str

var title : str

class SuccessLiteral (*args, **kwds)

Expand source code

class SuccessLiteral(Enum):
    boolean_True = True

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 boolean_True

class TrackDetail (**data: Any)

Expand source code

class TrackDetail(RegistryBaseModel):
    track: str
    status: str
    scenario_count: int
    passed_count: int
    duration_ms: float
    has_coverage_gap_skip: bool | 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var duration_ms : float

var has_coverage_gap_skip : bool | None

var model_config

var passed_count : int

var scenario_count : int

var status : str

var track : 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

• RegistryBaseModel
• pydantic.main.BaseModel

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

class VerdictSource (*args, **kwds)

Expand source code

class VerdictSource(Enum):
    heartbeat = "heartbeat"
    owner_test = "owner_test"
    manual = "manual"
    webhook = "webhook"
    NoneType_None = None

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 NoneType_None

var heartbeat

var manual

var owner_test

var webhook

class VerificationBadge (**data: Any)

Expand source code

class VerificationBadge(RegistryBaseModel):
    role: Annotated[
        Role,
        Field(description="AdCP protocol this badge covers (enums/adcp-protocol.json)."),
    ]
    adcp_version: Annotated[
        str,
        Field(
            description="AdCP release this badge was issued against, MAJOR.MINOR (e.g. '3.0', '3.1'). Load-bearing for badge identity — pairs with the (agent_url, role, adcp_version) PK."
        ),
    ]
    verified_at: str
    verified_specialisms: Annotated[
        list[VerifiedSpecialism],
        Field(
            description="Specialisms demonstrably passed (enums/specialism.json). Preview specialisms are excluded from stable badges."
        ),
    ]
    verification_modes: Annotated[
        list[VerificationMode],
        Field(
            description="Verification axes earned. 'spec' = AdCP storyboards pass for the declared specialisms. 'live' = AAO has observed real production traffic via canonical campaigns. Always non-empty when a badge is present; an absent badge is conveyed by the parent record being omitted, not by an empty array.",
            min_length=1,
        ),
    ]
    verified_protocol_version: str | None
    badge_url: Annotated[
        str | None,
        Field(
            description="Legacy URL — auto-upgrades to the highest active version. For version-pinned embedding, derive `/api/registry/agents/{encoded_url}/badge/{role}/{adcp_version}.svg` where `{encoded_url}` is `encodeURIComponent(agent_url)`."
        ),
    ] = 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

• RegistryBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str

var badge_url : str | None

var model_config

var role : Role

var verification_modes : list[VerificationMode]

var verified_at : str

var verified_protocol_version : str | None

var verified_specialisms : list[VerifiedSpecialism]

class VerificationMode (*args, **kwds)

Expand source code

class VerificationMode(Enum):
    spec = "spec"
    live = "live"

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 live

var spec

class VerifiedByAao (*args, **kwds)

Expand source code

class VerifiedByAao(Enum):
    boolean_False = False

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 boolean_False

class VerifiedRole (*args, **kwds)

Expand source code

class VerifiedRole(Enum):
    media_buy = "media-buy"
    signals = "signals"
    governance = "governance"
    creative = "creative"
    brand = "brand"
    sponsored_intelligence = "sponsored-intelligence"
    measurement = "measurement"

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

var creative

var governance

var measurement

var media_buy

var signals

var sponsored_intelligence

class VerifiedSpecialism (*args, **kwds)

Expand source code

class VerifiedSpecialism(Enum):
    audience_sync = "audience-sync"
    brand_rights = "brand-rights"
    collection_lists = "collection-lists"
    content_standards = "content-standards"
    creative_ad_server = "creative-ad-server"
    creative_generative = "creative-generative"
    creative_template = "creative-template"
    creative_transformers = "creative-transformers"
    governance_aware_seller = "governance-aware-seller"
    governance_delivery_monitor = "governance-delivery-monitor"
    governance_spend_authority = "governance-spend-authority"
    property_lists = "property-lists"
    sales_broadcast_tv = "sales-broadcast-tv"
    sales_catalog_driven = "sales-catalog-driven"
    sales_guaranteed = "sales-guaranteed"
    sales_non_guaranteed = "sales-non-guaranteed"
    sales_proposal_mode = "sales-proposal-mode"
    sales_social = "sales-social"
    signal_marketplace = "signal-marketplace"
    signal_owned = "signal-owned"
    signed_requests = "signed-requests"
    sponsored_intelligence = "sponsored-intelligence"

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 audience_sync

var brand_rights

var collection_lists

var content_standards

var creative_ad_server

var creative_generative

var creative_template

var creative_transformers

var governance_aware_seller

var governance_delivery_monitor

var governance_spend_authority

var property_lists

var sales_broadcast_tv

var sales_catalog_driven

var sales_guaranteed

var sales_non_guaranteed

var sales_proposal_mode

var sales_social

var signal_marketplace

var signal_owned

var signed_requests

var sponsored_intelligence