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.2/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.2/adagents.json',
                    'properties': [
                        {
                            'property_type': 'website',
                            'name': 'Example Site',
                            'identifiers': [{'type': 'domain', 'value': 'example.com'}],
                            'publisher_domain': 'example.com',
                        }
                    ],
                    'authorized_agents': [
                        {
                            'url': 'https://agent.example.com',
                            'authorized_for': 'Official sales agent',
                            'authorization_type': 'property_tags',
                            'property_tags': ['all'],
                        }
                    ],
                    'tags': {
                        'all': {
                            'name': 'All Properties',
                            'description': 'All properties in this file',
                        }
                    },
                    'last_updated': '2025-01-10T12:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.2/adagents.json',
                    'contact': {
                        'name': 'Meta Advertising Operations',
                        'email': 'adops@meta.com',
                        'domain': 'meta.com',
                        'seller_id': 'pub-meta-12345',
                        'tag_id': '12345',
                        'privacy_policy_url': 'https://www.meta.com/privacy/policy',
                    },
                    'properties': [
                        {
                            'property_type': 'mobile_app',
                            'name': 'Instagram',
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'com.burbn.instagram'},
                                {'type': 'android_package', 'value': 'com.instagram.android'},
                            ],
                            'tags': ['meta_network', 'social_media'],
                            'supported_channels': ['social', 'display', 'olv'],
                            'publisher_domain': 'instagram.com',
                        },
                        {
                            'property_type': 'mobile_app',
                            'name': 'Facebook',
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'com.facebook.Facebook'},
                                {'type': 'android_package', 'value': 'com.facebook.katana'},
                            ],
                            'tags': ['meta_network', 'social_media'],
                            'supported_channels': ['social', 'display', 'olv'],
                            'publisher_domain': 'facebook.com',
                        },
                        {
                            'property_type': 'mobile_app',
                            'name': 'WhatsApp',
                            'identifiers': [
                                {'type': 'ios_bundle', 'value': 'net.whatsapp.WhatsApp'},
                                {'type': 'android_package', 'value': 'com.whatsapp'},
                            ],
                            'tags': ['meta_network', 'messaging'],
                            'supported_channels': ['social', 'display'],
                            'publisher_domain': 'whatsapp.com',
                        },
                    ],
                    'tags': {
                        'meta_network': {
                            'name': 'Meta Network',
                            'description': 'All Meta-owned properties',
                        },
                        'social_media': {
                            'name': 'Social Media Apps',
                            'description': 'Social networking applications',
                        },
                        'messaging': {
                            'name': 'Messaging Apps',
                            'description': 'Messaging and communication apps',
                        },
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://meta-ads.com',
                            'authorized_for': 'All Meta properties',
                            'authorization_type': 'property_tags',
                            'property_tags': ['meta_network'],
                        }
                    ],
                    'last_updated': '2025-01-10T15:30:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.2/adagents.json',
                    'contact': {'name': 'Tumblr Advertising'},
                    'properties': [
                        {
                            'property_type': 'website',
                            'name': 'Tumblr Corporate',
                            'identifiers': [{'type': 'domain', 'value': 'tumblr.com'}],
                            'tags': ['corporate'],
                            'publisher_domain': 'tumblr.com',
                        }
                    ],
                    'tags': {
                        'corporate': {
                            'name': 'Corporate Properties',
                            'description': 'Tumblr-owned corporate properties (not user blogs)',
                        }
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://tumblr-sales.com',
                            'authorized_for': 'Tumblr corporate properties only',
                            'authorization_type': 'property_tags',
                            'property_tags': ['corporate'],
                        }
                    ],
                    'last_updated': '2025-01-10T16:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.2/adagents.json',
                    'contact': {
                        'name': 'Example Third-Party Sales Agent',
                        'email': 'sales@agent.example',
                        'domain': 'agent.example',
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://agent.example/api',
                            'authorized_for': 'CNN CTV properties via publisher authorization',
                            'authorization_type': 'publisher_properties',
                            'publisher_properties': [
                                {
                                    'publisher_domain': 'cnn.com',
                                    'selection_type': 'by_id',
                                    'property_ids': ['cnn_ctv_app'],
                                }
                            ],
                        },
                        {
                            'url': 'https://agent.example/api',
                            'authorized_for': 'All CTV properties from multiple publishers',
                            'authorization_type': 'publisher_properties',
                            'publisher_properties': [
                                {
                                    'publisher_domain': 'cnn.com',
                                    'selection_type': 'by_tag',
                                    'property_tags': ['ctv'],
                                },
                                {
                                    'publisher_domain': 'espn.com',
                                    'selection_type': 'by_tag',
                                    'property_tags': ['ctv'],
                                },
                            ],
                        },
                    ],
                    'last_updated': '2025-01-10T17:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.2/adagents.json',
                    'contact': {
                        'name': 'Premium News Publisher',
                        'email': 'adops@news.example.com',
                        'domain': 'news.example.com',
                    },
                    'properties': [
                        {
                            'property_type': 'website',
                            'name': 'News Example',
                            'identifiers': [{'type': 'domain', 'value': 'news.example.com'}],
                            'tags': ['premium', 'news'],
                            'publisher_domain': 'news.example.com',
                        }
                    ],
                    'tags': {
                        'premium': {
                            'name': 'Premium Properties',
                            'description': 'High-quality, brand-safe properties',
                        },
                        'news': {
                            'name': 'News Properties',
                            'description': 'News and journalism content',
                        },
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://sales.news.example.com',
                            'authorized_for': 'All news properties',
                            'authorization_type': 'property_tags',
                            'property_tags': ['news'],
                        }
                    ],
                    'property_features': [
                        {
                            'url': 'https://api.scope3.com',
                            'name': 'Scope3',
                            'features': ['carbon_score', 'sustainability_grade'],
                            'publisher_id': 'pub_news_12345',
                        },
                        {
                            'url': 'https://api.tagtoday.net',
                            'name': 'TAG',
                            'features': [
                                'tag_certified_against_fraud',
                                'tag_brand_safety_certified',
                            ],
                        },
                        {
                            'url': 'https://api.onetrust.com',
                            'name': 'OneTrust',
                            'features': ['gdpr_compliant', 'tcf_registered', 'ccpa_compliant'],
                            'publisher_id': 'ot_news_67890',
                        },
                    ],
                    'last_updated': '2025-01-10T18:00:00Z',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.2/adagents.json',
                    'contact': {
                        'name': 'Polk Automotive Data',
                        'email': 'partnerships@polk.com',
                        'domain': 'polk.com',
                    },
                    'signals': [
                        {
                            'id': 'likely_tesla_buyers',
                            'name': 'Likely Tesla Buyers',
                            'description': 'Consumers modeled as likely to purchase a Tesla in the next 12 months based on vehicle registration, financial, and behavioral data',
                            'value_type': 'binary',
                            'category': 'purchase_intent',
                            'tags': ['automotive', 'premium'],
                        },
                        {
                            'id': 'vehicle_ownership',
                            'name': 'Current Vehicle Ownership',
                            'description': 'Current vehicle make owned by the consumer',
                            'value_type': 'categorical',
                            'category': 'ownership',
                            'allowed_values': [
                                'tesla',
                                'bmw',
                                'mercedes',
                                'audi',
                                'lexus',
                                'other_luxury',
                                'non_luxury',
                            ],
                            'tags': ['automotive'],
                        },
                        {
                            'id': 'purchase_propensity',
                            'name': 'Auto Purchase Propensity',
                            'description': 'Likelihood score of purchasing any new vehicle in the next 6 months',
                            'value_type': 'numeric',
                            'category': 'purchase_intent',
                            'range': {'min': 0, 'max': 1, 'unit': 'score'},
                            'tags': ['automotive'],
                        },
                    ],
                    'signal_tags': {
                        'automotive': {
                            'name': 'Automotive Signals',
                            'description': 'Vehicle-related audience segments',
                        },
                        'premium': {
                            'name': 'Premium Signals',
                            'description': 'High-value premium audience segments',
                        },
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://liveramp.com/.well-known/adcp/signals',
                            'authorized_for': 'All Polk automotive signals via LiveRamp',
                            'authorization_type': 'signal_tags',
                            'signal_tags': ['automotive'],
                        },
                        {
                            'url': 'https://the-trade-desk.com/.well-known/adcp/signals',
                            'authorized_for': 'Polk premium signals only',
                            'authorization_type': 'signal_ids',
                            'signal_ids': ['likely_tesla_buyers'],
                        },
                    ],
                    'last_updated': '2025-01-15T10:00:00Z',
                },
            ],
            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

• AdCPBaseModel
• pydantic.main.BaseModel

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

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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
    contact: Annotated[
        Contact | None,
        Field(
            description='Contact information for the entity managing this adagents.json file (may be publisher or third-party operator)'
        ),
    ] = 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
    shows: Annotated[
        list[show.Show] | None,
        Field(
            description='Shows produced or distributed by this publisher. Declares the content programs whose inventory is sold through authorized agents. Products in get_products responses reference these shows by show_id.'
        ),
    ] = 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
    authorized_agents: Annotated[
        list[
            AuthorizedAgents
            | AuthorizedAgents1
            | AuthorizedAgents2
            | AuthorizedAgents3
            | AuthorizedAgents4
            | AuthorizedAgents5
        ],
        Field(
            description='Array of sales agents authorized to sell inventory for properties in this file',
            min_length=1,
        ),
    ]
    last_updated: Annotated[
        AwareDatetime | None,
        Field(description='ISO 8601 timestamp indicating when this file was last updated'),
    ] = 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
    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
    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

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorized_agents : list[AuthorizedAgents | AuthorizedAgents1 | AuthorizedAgents2 | AuthorizedAgents3 | AuthorizedAgents4 | AuthorizedAgents5]

var contact : Contact | None

var field_schema : str | None

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var properties : list[Property] | None

var property_features : list[PropertyFeature] | None

var shows : list[Show] | None

var signal_tags : dict[str, SignalTags] | None

var signals : list[SignalDefinition] | None

var tags : dict[str, Tags] | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents (**data: Any)

Expand source code

class AuthorizedAgents(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['property_ids'],
        Field(description='Discriminator indicating authorization by specific property IDs'),
    ]
    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,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['property_ids']

var authorized_for : str

var model_config

var property_ids : list[PropertyId]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents1 (**data: Any)

Expand source code

class AuthorizedAgents1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['property_tags'],
        Field(description='Discriminator indicating authorization by property tags'),
    ]
    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,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['property_tags']

var authorized_for : str

var model_config

var property_tags : list[PropertyTag]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents2 (**data: Any)

Expand source code

class AuthorizedAgents2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['inline_properties'],
        Field(description='Discriminator indicating authorization by inline property definitions'),
    ]
    properties: Annotated[
        list[property.Property],
        Field(
            description='Specific properties this agent is authorized for (alternative to property_ids/property_tags)',
            min_length=1,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['inline_properties']

var authorized_for : str

var model_config

var properties : list[Property]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents3 (**data: Any)

Expand source code

class AuthorizedAgents3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what this agent is authorized to sell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['publisher_properties'],
        Field(
            description='Discriminator indicating authorization for properties from other publisher domains'
        ),
    ]
    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,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['publisher_properties']

var authorized_for : str

var model_config

var publisher_properties : list[PublisherPropertySelector]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents4 (**data: Any)

Expand source code

class AuthorizedAgents4(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what signals this agent is authorized to resell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['signal_ids'],
        Field(description='Discriminator indicating authorization by specific signal IDs'),
    ]
    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,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['signal_ids']

var authorized_for : str

var model_config

var signal_ids : list[SignalId]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizedAgents5 (**data: Any)

Expand source code

class AuthorizedAgents5(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]
    authorized_for: Annotated[
        str,
        Field(
            description='Human-readable description of what signals this agent is authorized to resell',
            max_length=500,
            min_length=1,
        ),
    ]
    authorization_type: Annotated[
        Literal['signal_tags'],
        Field(description='Discriminator indicating authorization by signal tags'),
    ]
    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,
        ),
    ]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['signal_tags']

var authorized_for : str

var model_config

var signal_tags : list[SignalTag]

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Contact (**data: Any)

Expand source code

class Contact(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    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,
        ),
    ]
    email: Annotated[
        EmailStr | None,
        Field(
            description='Contact email for questions or issues with this authorization file',
            max_length=255,
            min_length=1,
        ),
    ] = None
    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
    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
    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

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

• AdCPBaseModel
• pydantic.main.BaseModel

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

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyFeature (**data: Any)

Expand source code

class PropertyFeature(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description="The agent's API endpoint URL")]
    name: Annotated[
        str,
        Field(
            description="Human-readable name of the vendor/agent (e.g., 'Scope3', 'TAG', 'OneTrust')"
        ),
    ]
    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,
        ),
    ]
    publisher_id: Annotated[
        str | None, Field(description='Optional publisher identifier at this agent (for lookup)')
    ] = 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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var features : list[str]

var model_config

var name : str

var publisher_id : str | None

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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(Tags):
    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

• Tags
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• Tags:
  • model_dump
  • model_dump_json
  • model_summary

class Tags (**data: Any)

Expand source code

class Tags(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    name: Annotated[str, Field(description='Human-readable name for this tag')]
    description: Annotated[str, Field(description='Description of what this tag represents')]

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

• AdCPBaseModel
• pydantic.main.BaseModel

Subclasses

• SignalTags

Class variables

var description : str

var model_config

var name : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary