Module adcp.types.generated_poc.adagents

Classes

class AdcpAgentsAuthorization (root: RootModelRootType = PydanticUndefined, **data)
Expand source code 
class AdcpAgentsAuthorization(RootModel[AdcpAgentsAuthorization1 | AdcpAgentsAuthorization2]):
    root: Annotated[
        AdcpAgentsAuthorization1 | AdcpAgentsAuthorization2,
        Field(
            description='Declaration of authorized agents for advertising inventory and data signals. Hosted at /.well-known/adagents.json on publisher domains (for properties) or data provider domains (for signals). Can either contain the full structure inline or reference an authoritative URL.',
            examples=[
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authoritative_location': 'https://cdn.example.com/adagents/v2/adagents.json',
                    'last_updated': '2025-01-15T10:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'property_tags',
                            'authorized_for': 'Official sales agent',
                            'countries': ['US', 'CA'],
                            'delegation_type': 'direct',
                            'effective_from': '2025-01-01T00:00:00Z',
                            'exclusive': True,
                            'placement_ids': ['homepage_banner'],
                            'property_tags': ['all'],
                            'url': 'https://agent.example.com',
                        }
                    ],
                    'last_updated': '2025-01-10T12:00:00Z',
                    'placement_tags': {
                        'display': {
                            'description': 'Standard display placements',
                            'name': 'Display',
                        },
                        'homepage': {
                            'description': 'Placements that render on the homepage',
                            'name': 'Homepage',
                        },
                        'premium': {
                            'description': 'Premium monetization placements',
                            'name': 'Premium',
                        },
                    },
                    'placements': [
                        {
                            'format_ids': [
                                {
                                    'agent_url': 'https://creative.example.com',
                                    'id': 'display_728x90',
                                }
                            ],
                            'name': 'Homepage Banner',
                            'placement_id': 'homepage_banner',
                            'property_ids': ['example_site'],
                            'tags': ['homepage', 'display', 'premium'],
                        }
                    ],
                    'properties': [
                        {
                            'identifiers': [{'type': 'domain', 'value': 'example.com'}],
                            'name': 'Example Site',
                            'property_id': 'example_site',
                            'property_type': 'website',
                            'publisher_domain': 'example.com',
                        }
                    ],
                    'tags': {
                        'all': {
                            'description': 'All properties in this file',
                            'name': 'All Properties',
                        }
                    },
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'property_tags',
                            'authorized_for': 'All Meta properties',
                            'property_tags': ['meta_network'],
                            'url': 'https://meta-ads.com',
                        }
                    ],
                    'contact': {
                        'domain': 'meta.com',
                        'email': 'adops@meta.com',
                        'name': 'Meta Advertising Operations',
                        'privacy_policy_url': 'https://www.meta.com/privacy/policy',
                        'seller_id': 'pub-meta-12345',
                        'tag_id': '12345',
                    },
                    'last_updated': '2025-01-10T15:30:00Z',
                    'properties': [
                        {
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'com.burbn.instagram'},
                                {'type': 'android_package', 'value': 'com.instagram.android'},
                            ],
                            'name': 'Instagram',
                            'property_type': 'mobile_app',
                            'publisher_domain': 'instagram.com',
                            'supported_channels': ['social', 'display', 'olv'],
                            'tags': ['meta_network', 'social_media'],
                        },
                        {
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'com.facebook.Facebook'},
                                {'type': 'android_package', 'value': 'com.facebook.katana'},
                            ],
                            'name': 'Facebook',
                            'property_type': 'mobile_app',
                            'publisher_domain': 'facebook.com',
                            'supported_channels': ['social', 'display', 'olv'],
                            'tags': ['meta_network', 'social_media'],
                        },
                        {
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'net.whatsapp.WhatsApp'},
                                {'type': 'android_package', 'value': 'com.whatsapp'},
                            ],
                            'name': 'WhatsApp',
                            'property_type': 'mobile_app',
                            'publisher_domain': 'whatsapp.com',
                            'supported_channels': ['social', 'display'],
                            'tags': ['meta_network', 'messaging'],
                        },
                    ],
                    'tags': {
                        'messaging': {
                            'description': 'Messaging and communication apps',
                            'name': 'Messaging Apps',
                        },
                        'meta_network': {
                            'description': 'All Meta-owned properties',
                            'name': 'Meta Network',
                        },
                        'social_media': {
                            'description': 'Social networking applications',
                            'name': 'Social Media Apps',
                        },
                    },
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'property_tags',
                            'authorized_for': 'Tumblr corporate properties only',
                            'property_tags': ['corporate'],
                            'url': 'https://tumblr-sales.com',
                        }
                    ],
                    'contact': {'name': 'Tumblr Advertising'},
                    'last_updated': '2025-01-10T16:00:00Z',
                    'properties': [
                        {
                            'identifiers': [{'type': 'domain', 'value': 'tumblr.com'}],
                            'name': 'Tumblr Corporate',
                            'property_type': 'website',
                            'publisher_domain': 'tumblr.com',
                            'tags': ['corporate'],
                        }
                    ],
                    'tags': {
                        'corporate': {
                            'description': 'Tumblr-owned corporate properties (not user blogs)',
                            'name': 'Corporate Properties',
                        }
                    },
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'publisher_properties',
                            'authorized_for': 'CNN CTV properties via publisher authorization',
                            'publisher_properties': [
                                {
                                    'property_ids': ['cnn_ctv_app'],
                                    'publisher_domain': 'cnn.com',
                                    'selection_type': 'by_id',
                                }
                            ],
                            'url': 'https://agent.example/api',
                        },
                        {
                            'authorization_type': 'publisher_properties',
                            'authorized_for': 'All CTV properties from multiple publishers',
                            'publisher_properties': [
                                {
                                    'property_tags': ['ctv'],
                                    'publisher_domain': 'cnn.com',
                                    'selection_type': 'by_tag',
                                },
                                {
                                    'property_tags': ['ctv'],
                                    'publisher_domain': 'espn.com',
                                    'selection_type': 'by_tag',
                                },
                            ],
                            'url': 'https://agent.example/api',
                        },
                    ],
                    'contact': {
                        'domain': 'agent.example',
                        'email': 'sales@agent.example',
                        'name': 'Example Third-Party Sales Agent',
                    },
                    'last_updated': '2025-01-10T17:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'property_tags',
                            'authorized_for': 'All news properties',
                            'property_tags': ['news'],
                            'url': 'https://sales.news.example.com',
                        }
                    ],
                    'contact': {
                        'domain': 'news.example.com',
                        'email': 'adops@news.example.com',
                        'name': 'Premium News Publisher',
                    },
                    'last_updated': '2025-01-10T18:00:00Z',
                    'properties': [
                        {
                            'identifiers': [{'type': 'domain', 'value': 'news.example.com'}],
                            'name': 'News Example',
                            'property_type': 'website',
                            'publisher_domain': 'news.example.com',
                            'tags': ['premium', 'news'],
                        }
                    ],
                    'property_features': [
                        {
                            'features': ['carbon_score', 'sustainability_grade'],
                            'name': 'Scope3',
                            'publisher_id': 'pub_news_12345',
                            'url': 'https://api.scope3.com',
                        },
                        {
                            'features': [
                                'tag_certified_against_fraud',
                                'tag_brand_safety_certified',
                            ],
                            'name': 'TAG',
                            'url': 'https://api.tagtoday.net',
                        },
                        {
                            'features': ['gdpr_compliant', 'tcf_registered', 'ccpa_compliant'],
                            'name': 'OneTrust',
                            'publisher_id': 'ot_news_67890',
                            'url': 'https://api.onetrust.com',
                        },
                    ],
                    'tags': {
                        'news': {
                            'description': 'News and journalism content',
                            'name': 'News Properties',
                        },
                        'premium': {
                            'description': 'High-quality, brand-safe properties',
                            'name': 'Premium Properties',
                        },
                    },
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/adagents.json',
                    'authorized_agents': [
                        {
                            'authorization_type': 'signal_tags',
                            'authorized_for': 'All Polk automotive signals via LiveRamp',
                            'signal_tags': ['automotive'],
                            'url': 'https://liveramp.com/.well-known/adcp/signals',
                        },
                        {
                            'authorization_type': 'signal_ids',
                            'authorized_for': 'Polk premium signals only',
                            'signal_ids': ['likely_tesla_buyers'],
                            'url': 'https://the-trade-desk.com/.well-known/adcp/signals',
                        },
                    ],
                    'contact': {
                        'domain': 'polk.com',
                        'email': 'partnerships@polk.com',
                        'name': 'Polk Automotive Data',
                    },
                    'last_updated': '2025-01-15T10:00:00Z',
                    'signal_tags': {
                        'automotive': {
                            'description': 'Vehicle-related audience segments',
                            'name': 'Automotive Signals',
                        },
                        'premium': {
                            'description': 'High-value premium audience segments',
                            'name': 'Premium Signals',
                        },
                    },
                    'signals': [
                        {
                            'category': 'purchase_intent',
                            'description': 'Consumers modeled as likely to purchase a Tesla in the next 12 months based on vehicle registration, financial, and behavioral data',
                            'id': 'likely_tesla_buyers',
                            'name': 'Likely Tesla Buyers',
                            'tags': ['automotive', 'premium'],
                            'value_type': 'binary',
                        },
                        {
                            'allowed_values': [
                                'tesla',
                                'bmw',
                                'mercedes',
                                'audi',
                                'lexus',
                                'other_luxury',
                                'non_luxury',
                            ],
                            'category': 'ownership',
                            'description': 'Current vehicle make owned by the consumer',
                            'id': 'vehicle_ownership',
                            'name': 'Current Vehicle Ownership',
                            'tags': ['automotive'],
                            'value_type': 'categorical',
                        },
                        {
                            'category': 'purchase_intent',
                            'description': 'Likelihood score of purchasing any new vehicle in the next 6 months',
                            'id': 'purchase_propensity',
                            'name': 'Auto Purchase Propensity',
                            'range': {'max': 1, 'min': 0, 'unit': 'score'},
                            'tags': ['automotive'],
                            'value_type': 'numeric',
                        },
                    ],
                },
            ],
            title='AdCP Agents Authorization',
        ),
    ]

    def __getattr__(self, name: str) -> Any:
        """Proxy attribute access to the wrapped type."""
        if name.startswith('_'):
            raise AttributeError(name)
        return getattr(self.root, name)

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[AdcpAgentsAuthorization1, AdcpAgentsAuthorization2]]
  • pydantic.root_model.RootModel
  • pydantic.main.BaseModel
  • typing.Generic

Class variables

var model_config
var root : AdcpAgentsAuthorization1 | AdcpAgentsAuthorization2
class AdcpAgentsAuthorization1 (**data: Any)
Expand source code 
class AdcpAgentsAuthorization1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    field_schema: Annotated[
        str | None,
        Field(alias='$schema', description='JSON Schema identifier for this adagents.json file'),
    ] = None
    authoritative_location: Annotated[
        AnyUrl,
        Field(
            description='HTTPS URL of the authoritative adagents.json file. When present, this file is a reference and the authoritative location contains the actual agent authorization data.'
        ),
    ]
    last_updated: Annotated[
        AwareDatetime | None,
        Field(description='ISO 8601 timestamp indicating when this reference was last updated'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authoritative_location : pydantic.networks.AnyUrl
var field_schema : str | None
var last_updated : pydantic.types.AwareDatetime | None
var model_config

Inherited members

class AdcpAgentsAuthorization2 (**data: Any)
Expand source code 
class AdcpAgentsAuthorization2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    field_schema: Annotated[
        str | None,
        Field(alias='$schema', description='JSON Schema identifier for this adagents.json file'),
    ] = None
    authorized_agents: Annotated[
        list[
            AuthorizedAgents
            | AuthorizedAgents1
            | AuthorizedAgents2
            | AuthorizedAgents3
            | AuthorizedAgents4
            | AuthorizedAgents5
        ],
        Field(
            description='Array of sales agents authorized to make inventory from this file available to buyers. Authorization can be scoped to specific properties, collections, countries, and time windows, with optional delegation metadata indicating whether the path is direct, delegated, or network-mediated.',
            min_length=1,
        ),
    ]
    collections: Annotated[
        list[collection.Collection] | None,
        Field(
            description='Collections produced or distributed by this publisher. Declares the content programs whose inventory is sold through authorized agents. Products in get_products responses reference these collections by collection_id.'
        ),
    ] = None
    contact: Annotated[
        Contact | None,
        Field(
            description='Contact information for the entity managing this adagents.json file (may be publisher or third-party operator)'
        ),
    ] = None
    last_updated: Annotated[
        AwareDatetime | None,
        Field(description='ISO 8601 timestamp indicating when this file was last updated'),
    ] = None
    placement_tags: Annotated[
        dict[str, PlacementTags] | None,
        Field(
            description='Metadata for each tag referenced by placements. Provides human-readable context for publisher-defined placement tag values used in grouping and authorization.'
        ),
    ] = None
    placements: Annotated[
        list[placement_definition.PlacementDefinition] | None,
        Field(
            description='Canonical placement definitions for properties in this file. Products SHOULD reuse these placement_id values when exposing inventory in get_products, and authorized agents can scope authorization to these placement IDs.',
            min_length=1,
        ),
    ] = None
    properties: Annotated[
        list[property.Property] | None,
        Field(
            description='Array of all properties covered by this adagents.json file. Defines the canonical property list that authorized agents reference.',
            min_length=1,
        ),
    ] = None
    property_features: Annotated[
        list[PropertyFeature] | None,
        Field(
            description='[AdCP 3.0] Optional list of agents that provide property feature data (certifications, scores, compliance status). Used for discovery - actual data is accessed through property list filters.'
        ),
    ] = None
    signal_tags: Annotated[
        dict[str, SignalTags] | None,
        Field(
            description='Metadata for each tag referenced by signals. Provides human-readable context for signal tag values.'
        ),
    ] = None
    signals: Annotated[
        list[signal_definition.SignalDefinition] | None,
        Field(
            description='Signal catalog published by this data provider. Signals agents reference these signals via data_provider_domain + signal_id.',
            min_length=1,
        ),
    ] = None
    tags: Annotated[
        dict[str, Tags] | None,
        Field(
            description='Metadata for each tag referenced by properties. Provides human-readable context for property tag values.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorized_agents : list[AuthorizedAgents | AuthorizedAgents1 | AuthorizedAgents2 | AuthorizedAgents3 | AuthorizedAgents4 | AuthorizedAgents5]
var collections : list[Collection] | None
var contact : Contact | None
var field_schema : str | None
var last_updated : pydantic.types.AwareDatetime | None
var model_config
var placement_tags : dict[str, PlacementTags] | None
var placements : list[PlacementDefinition] | None
var properties : list[Property] | None
var property_features : list[PropertyFeature] | None
var signal_tags : dict[str, SignalTags] | None
var signals : list[SignalDefinition] | None
var tags : dict[str, Tags] | None

Inherited members

class AuthorizedAgents (**data: Any)
Expand source code 
class AuthorizedAgents(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['property_ids'],
        Field(description='Discriminator indicating authorization by specific property IDs'),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    collections: Annotated[
        list[collection_selector.CollectionSelector] | None,
        Field(
            description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.',
            min_length=1,
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.',
            min_length=1,
        ),
    ] = None
    delegation_type: Annotated[
        DelegationType | None,
        Field(
            description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint."
        ),
    ] = None
    effective_from: Annotated[
        AwareDatetime | None,
        Field(description='Optional start time for this authorization window.'),
    ] = None
    effective_until: Annotated[
        AwareDatetime | None, Field(description='Optional end time for this authorization window.')
    ] = None
    exclusive: Annotated[
        bool | None,
        Field(
            description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory."
        ),
    ] = None
    placement_ids: Annotated[
        list[str] | None,
        Field(
            description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.',
            min_length=1,
        ),
    ] = None
    placement_tags: Annotated[
        list[str] | None,
        Field(
            description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.',
            min_length=1,
        ),
    ] = None
    property_ids: Annotated[
        list[property_id.PropertyId],
        Field(
            description='Property IDs this agent is authorized for. Resolved against the top-level properties array in this file',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['property_ids']
var authorized_for : str
var collections : list[CollectionSelector] | None
var countries : list[Country] | None
var delegation_type : DelegationType | None
var effective_from : pydantic.types.AwareDatetime | None
var effective_until : pydantic.types.AwareDatetime | None
var exclusive : bool | None
var model_config
var placement_ids : list[str] | None
var placement_tags : list[str] | None
var property_ids : list[PropertyId]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class AuthorizedAgents1 (**data: Any)
Expand source code 
class AuthorizedAgents1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['property_tags'],
        Field(description='Discriminator indicating authorization by property tags'),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    collections: Annotated[
        list[collection_selector.CollectionSelector] | None,
        Field(
            description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.',
            min_length=1,
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.',
            min_length=1,
        ),
    ] = None
    delegation_type: Annotated[
        DelegationType | None,
        Field(
            description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint."
        ),
    ] = None
    effective_from: Annotated[
        AwareDatetime | None,
        Field(description='Optional start time for this authorization window.'),
    ] = None
    effective_until: Annotated[
        AwareDatetime | None, Field(description='Optional end time for this authorization window.')
    ] = None
    exclusive: Annotated[
        bool | None,
        Field(
            description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory."
        ),
    ] = None
    placement_ids: Annotated[
        list[str] | None,
        Field(
            description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.',
            min_length=1,
        ),
    ] = None
    placement_tags: Annotated[
        list[str] | None,
        Field(
            description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.',
            min_length=1,
        ),
    ] = None
    property_tags: Annotated[
        list[property_tag.PropertyTag],
        Field(
            description='Tags identifying which properties this agent is authorized for. Resolved against the top-level properties array in this file using tag matching',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['property_tags']
var authorized_for : str
var collections : list[CollectionSelector] | None
var countries : list[Country] | None
var delegation_type : DelegationType | None
var effective_from : pydantic.types.AwareDatetime | None
var effective_until : pydantic.types.AwareDatetime | None
var exclusive : bool | None
var model_config
var placement_ids : list[str] | None
var placement_tags : list[str] | None
var property_tags : list[PropertyTag]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class AuthorizedAgents2 (**data: Any)
Expand source code 
class AuthorizedAgents2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['inline_properties'],
        Field(description='Discriminator indicating authorization by inline property definitions'),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    collections: Annotated[
        list[collection_selector.CollectionSelector] | None,
        Field(
            description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.',
            min_length=1,
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.',
            min_length=1,
        ),
    ] = None
    delegation_type: Annotated[
        DelegationType | None,
        Field(
            description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint."
        ),
    ] = None
    effective_from: Annotated[
        AwareDatetime | None,
        Field(description='Optional start time for this authorization window.'),
    ] = None
    effective_until: Annotated[
        AwareDatetime | None, Field(description='Optional end time for this authorization window.')
    ] = None
    exclusive: Annotated[
        bool | None,
        Field(
            description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory."
        ),
    ] = None
    placement_ids: Annotated[
        list[str] | None,
        Field(
            description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.',
            min_length=1,
        ),
    ] = None
    placement_tags: Annotated[
        list[str] | None,
        Field(
            description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.',
            min_length=1,
        ),
    ] = None
    properties: Annotated[
        list[property.Property],
        Field(
            description='Specific properties this agent is authorized for (alternative to property_ids/property_tags)',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['inline_properties']
var authorized_for : str
var collections : list[CollectionSelector] | None
var countries : list[Country] | None
var delegation_type : DelegationType | None
var effective_from : pydantic.types.AwareDatetime | None
var effective_until : pydantic.types.AwareDatetime | None
var exclusive : bool | None
var model_config
var placement_ids : list[str] | None
var placement_tags : list[str] | None
var properties : list[Property]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class AuthorizedAgents3 (**data: Any)
Expand source code 
class AuthorizedAgents3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['publisher_properties'],
        Field(
            description='Discriminator indicating authorization for properties from other publisher domains'
        ),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    collections: Annotated[
        list[collection_selector.CollectionSelector] | None,
        Field(
            description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.',
            min_length=1,
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.',
            min_length=1,
        ),
    ] = None
    delegation_type: Annotated[
        DelegationType | None,
        Field(
            description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint."
        ),
    ] = None
    effective_from: Annotated[
        AwareDatetime | None,
        Field(description='Optional start time for this authorization window.'),
    ] = None
    effective_until: Annotated[
        AwareDatetime | None, Field(description='Optional end time for this authorization window.')
    ] = None
    exclusive: Annotated[
        bool | None,
        Field(
            description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory."
        ),
    ] = None
    placement_ids: Annotated[
        list[str] | None,
        Field(
            description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.',
            min_length=1,
        ),
    ] = None
    placement_tags: Annotated[
        list[str] | None,
        Field(
            description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.',
            min_length=1,
        ),
    ] = None
    publisher_properties: Annotated[
        list[publisher_property_selector.PublisherPropertySelector],
        Field(
            description='Properties from other publisher domains this agent is authorized for. Each entry specifies a publisher domain and which of their properties this agent can sell',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['publisher_properties']
var authorized_for : str
var collections : list[CollectionSelector] | None
var countries : list[Country] | None
var delegation_type : DelegationType | None
var effective_from : pydantic.types.AwareDatetime | None
var effective_until : pydantic.types.AwareDatetime | None
var exclusive : bool | None
var model_config
var placement_ids : list[str] | None
var placement_tags : list[str] | None
var publisher_properties : list[PublisherPropertySelector]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class AuthorizedAgents4 (**data: Any)
Expand source code 
class AuthorizedAgents4(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['signal_ids'],
        Field(description='Discriminator indicating authorization by specific signal IDs'),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what signals this agent is authorized to resell',
            max_length=500,
            min_length=1,
        ),
    ]
    signal_ids: Annotated[
        list[SignalId],
        Field(
            description='Signal IDs this agent is authorized to resell. Resolved against the top-level signals array in this file',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['signal_ids']
var authorized_for : str
var model_config
var signal_ids : list[SignalId]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class AuthorizedAgents5 (**data: Any)
Expand source code 
class AuthorizedAgents5(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    authorization_type: Annotated[
        Literal['signal_tags'],
        Field(description='Discriminator indicating authorization by signal tags'),
    ]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what signals this agent is authorized to resell',
            max_length=500,
            min_length=1,
        ),
    ]
    signal_tags: Annotated[
        list[SignalTag],
        Field(
            description='Signal tags this agent is authorized for. Agent can resell all signals with these tags',
            min_length=1,
        ),
    ]
    signing_keys: Annotated[
        list[agent_signing_key.AgentSigningKey] | None,
        Field(
            description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.',
            min_length=1,
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authorization_type : Literal['signal_tags']
var authorized_for : str
var model_config
var signal_tags : list[SignalTag]
var signing_keys : list[AgentSigningKey] | None
var url : pydantic.networks.AnyUrl

Inherited members

class Contact (**data: Any)
Expand source code 
class Contact(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    domain: Annotated[
        str | None,
        Field(
            description='Primary domain of the entity managing this file',
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ] = None
    email: Annotated[
        EmailStr | None,
        Field(
            description='Contact email for questions or issues with this authorization file',
            max_length=255,
            min_length=1,
        ),
    ] = None
    name: Annotated[
        str,
        Field(
            description="Name of the entity managing this file (e.g., 'Meta Advertising Operations', 'Clear Channel Digital')",
            max_length=255,
            min_length=1,
        ),
    ]
    privacy_policy_url: Annotated[
        AnyUrl | None,
        Field(
            description="URL to the entity's privacy policy. Used for consumer consent flows when interacting with this sales agent."
        ),
    ] = None
    seller_id: Annotated[
        str | None,
        Field(
            description='Seller ID from IAB Tech Lab sellers.json (if applicable)',
            max_length=255,
            min_length=1,
        ),
    ] = None
    tag_id: Annotated[
        str | None,
        Field(
            description='TAG Certified Against Fraud ID for verification (if applicable)',
            max_length=100,
            min_length=1,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var domain : str | None
var email : pydantic.networks.EmailStr | None
var model_config
var name : str
var privacy_policy_url : pydantic.networks.AnyUrl | None
var seller_id : str | None
var tag_id : str | None

Inherited members

class Country (root: RootModelRootType = PydanticUndefined, **data)
Expand source code 
class Country(RootModel[str]):
    root: Annotated[str, Field(pattern='^[A-Z]{2}$')]

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[str]
  • pydantic.root_model.RootModel
  • pydantic.main.BaseModel
  • typing.Generic

Class variables

var model_config
var root : str
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 PlacementTags (**data: Any)
Expand source code 
class PlacementTags(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    description: Annotated[
        str, Field(description='Description of what this placement tag represents')
    ]
    name: Annotated[str, Field(description='Human-readable name for this placement tag')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var description : str
var model_config
var name : str

Inherited members

class PropertyFeature (**data: Any)
Expand source code 
class PropertyFeature(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    features: Annotated[
        list[str],
        Field(
            description="Feature IDs this agent provides (e.g., 'carbon_score', 'tag_certified_against_fraud'). Use get_adcp_capabilities on the agent for full definitions.",
            min_length=1,
        ),
    ]
    name: Annotated[
        str,
        Field(
            description="Human-readable name of the vendor/agent (e.g., 'Scope3', 'TAG', 'OneTrust')"
        ),
    ]
    publisher_id: Annotated[
        str | None, Field(description='Optional publisher identifier at this agent (for lookup)')
    ] = None
    url: Annotated[AnyUrl, Field(description="The agent's API endpoint URL")]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var features : list[str]
var model_config
var name : str
var publisher_id : str | None
var url : pydantic.networks.AnyUrl

Inherited members

class SignalId (root: RootModelRootType = PydanticUndefined, **data)
Expand source code 
class SignalId(RootModel[str]):
    root: Annotated[str, Field(pattern='^[a-zA-Z0-9_-]+$')]

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[str]
  • pydantic.root_model.RootModel
  • pydantic.main.BaseModel
  • typing.Generic

Class variables

var model_config
var root : str
class SignalTag (root: RootModelRootType = PydanticUndefined, **data)
Expand source code 
class SignalTag(RootModel[str]):
    root: Annotated[str, Field(pattern='^[a-z0-9_-]+$')]

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[str]
  • pydantic.root_model.RootModel
  • pydantic.main.BaseModel
  • typing.Generic

Class variables

var model_config
var root : str
class SignalTags (**data: Any)
Expand source code 
class SignalTags(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    description: Annotated[str, Field(description='Description of what this tag represents')]
    name: Annotated[str, Field(description='Human-readable name for this tag')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

Subclasses

Class variables

var description : str
var model_config
var name : str

Inherited members

class Tags (**data: Any)
Expand source code 
class Tags(SignalTags):
    pass

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var model_config

Inherited members