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/latest/adagents.json',
                    'authoritative_location': 'https://cdn.example.com/adagents/v2/adagents.json',
                    'last_updated': '2025-01-15T10:00:00Z',
                },
                {
                    '$schema': '/schemas/latest/adagents.json',
                    'properties': [
                        {
                            'property_id': 'example_site',
                            'property_type': 'website',
                            'name': 'Example Site',
                            'identifiers': [{'type': 'domain', 'value': 'example.com'}],
                            'publisher_domain': 'example.com',
                        }
                    ],
                    'placements': [
                        {
                            'placement_id': 'homepage_banner',
                            'name': 'Homepage Banner',
                            'tags': ['homepage', 'display', 'premium'],
                            'property_ids': ['example_site'],
                            'format_ids': [
                                {
                                    'agent_url': 'https://creative.example.com',
                                    'id': 'display_728x90',
                                }
                            ],
                        }
                    ],
                    'placement_tags': {
                        'homepage': {
                            'name': 'Homepage',
                            'description': 'Placements that render on the homepage',
                        },
                        'display': {
                            'name': 'Display',
                            'description': 'Standard display placements',
                        },
                        'premium': {
                            'name': 'Premium',
                            'description': 'Premium monetization placements',
                        },
                    },
                    'authorized_agents': [
                        {
                            'url': 'https://agent.example.com',
                            'authorized_for': 'Official sales agent',
                            'authorization_type': 'property_tags',
                            'property_tags': ['all'],
                            'placement_ids': ['homepage_banner'],
                            'delegation_type': 'direct',
                            'exclusive': True,
                            'countries': ['US', 'CA'],
                            'effective_from': '2025-01-01T00:00:00Z',
                        }
                    ],
                    'tags': {
                        'all': {
                            'name': 'All Properties',
                            'description': 'All properties in this file',
                        }
                    },
                    'last_updated': '2025-01-10T12:00:00Z',
                },
                {
                    '$schema': '/schemas/latest/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/latest/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/latest/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/latest/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/latest/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. Because one deploy can change authorization across every publisher in the network, validators MUST cap response size, refuse redirects on the fetch, enforce short timeouts, and serve the previously cached file on transient 5xx. See docs/governance/property/managed-networks#security-considerations.'
        ),
    ]
    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
    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
    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
    tags: Annotated[
        dict[str, Tags] | None,
        Field(
            description='Metadata for each tag referenced by properties. Provides human-readable context for property tag values.'
        ),
    ] = 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
    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,
        ),
    ]
    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 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

• 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,
        ),
    ]
    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
    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
    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
    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
    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
    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
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

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 encryption_keys : list[AgentEncryptionKey] | 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

• 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,
        ),
    ]
    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
    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
    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
    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
    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
    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
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

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 encryption_keys : list[AgentEncryptionKey] | 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

• 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,
        ),
    ]
    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
    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
    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
    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
    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
    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
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

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 encryption_keys : list[AgentEncryptionKey] | 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

• 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,
        ),
    ]
    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
    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
    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
    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
    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
    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
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

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 encryption_keys : list[AgentEncryptionKey] | 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

• 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,
        ),
    ]
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['signal_ids']

var authorized_for : str

var encryption_keys : list[AgentEncryptionKey] | None

var model_config

var signal_ids : list[SignalId]

var signing_keys : list[AgentSigningKey] | None

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,
        ),
    ]
    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
    encryption_keys: Annotated[
        list[agent_encryption_key.AgentEncryptionKey] | None,
        Field(
            description='X25519 public keys for TMPX exposure token encryption. Each key identifies a cluster master that can decrypt TMPX tokens. Used with HPKE mode_base — read replicas encrypt with this public key, only the master can decrypt.',
            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

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var authorization_type : Literal['signal_tags']

var authorized_for : str

var encryption_keys : list[AgentEncryptionKey] | None

var model_config

var signal_tags : list[SignalTag]

var signing_keys : list[AgentSigningKey] | None

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 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',
    )
    name: Annotated[str, Field(description='Human-readable name for this placement tag')]
    description: Annotated[
        str, Field(description='Description of what this placement 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

Class variables

var description : str

var model_config

var name : str

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