Module adcp.types.generated_poc.brand

Classes

class AgenticCheckout (**data: Any)

Expand source code

class AgenticCheckout(AdCPBaseModel):
    endpoint: AnyUrl
    spec: Literal['openai_agentic_checkout_v1']

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 endpoint : pydantic.networks.AnyUrl

var model_config

var spec : Literal['openai_agentic_checkout_v1']

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Architecture (*args, **kwds)

Expand source code

class Architecture(Enum):
    branded_house = 'branded_house'
    house_of_brands = 'house_of_brands'
    hybrid = 'hybrid'

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 branded_house

var house_of_brands

var hybrid

class Asset (**data: Any)

Expand source code

class Asset(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    asset_id: Annotated[str, Field(description='Unique identifier')]
    asset_type: Annotated[AssetType, Field(description='Asset type')]
    duration_seconds: float | None = None
    format: Annotated[str | None, Field(description='File format (jpg, mp4, etc.)')] = None
    height: int | None = None
    name: Annotated[str | None, Field(description='Human-readable name')] = None
    tags: Annotated[
        list[str] | None,
        Field(description="Tags for discovery (e.g., 'hero', 'lifestyle', 'product')"),
    ] = None
    url: Annotated[AnyUrl, Field(description='URL to asset')]
    width: int | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 asset_id : str

var asset_type : AssetType

var duration_seconds : float | None

var format : str | None

var height : int | None

var model_config

var name : str | None

var tags : list[str] | None

var url : pydantic.networks.AnyUrl

var width : int | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AssetType (*args, **kwds)

Expand source code

class AssetType(Enum):
    image = 'image'
    video = 'video'
    audio = 'audio'
    text = 'text'

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 audio

var image

var text

var video

class AuthorizedOperator (**data: Any)

Expand source code

class AuthorizedOperator(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    brands: Annotated[
        list[Brand1],
        Field(
            description="Brand IDs this operator is authorized for. Use ['*'] for all brands in the portfolio.",
            min_length=1,
        ),
    ]
    countries: Annotated[
        list[Country] | None,
        Field(
            description='ISO 3166-1 alpha-2 country codes where this authorization applies. Omit for global authorization.'
        ),
    ] = None
    domain: Annotated[
        Domain, Field(description="Domain of the authorized operator (e.g., 'groupm.com')")
    ]

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 brands : list[Brand1]

var countries : list[Country] | None

var domain : Domain

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Avatar (**data: Any)

Expand source code

class Avatar(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    avatar_id: str | None = None
    provider: str | None = None
    settings: dict[str, Any] | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 avatar_id : str | None

var model_config

var provider : str | None

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

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Brand (**data: Any)

Expand source code

class Brand(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    assets: Annotated[list[Asset] | None, Field(description='Brand asset library')] = None
    avatar: Annotated[Avatar | None, Field(description='Visual avatar configuration')] = None
    brand_agent: Annotated[
        BrandAgent | None,
        Field(
            description='Brand agent that provides dynamic brand manifest data. Agent implements get_brand_manifest({ house, brand_id }).'
        ),
    ] = None
    colors: Colors | None = None
    description: Annotated[str | None, Field(description='Brand description')] = None
    disclaimers: Annotated[
        list[Disclaimer] | None, Field(description='Legal disclaimers for creatives')
    ] = None
    fonts: Fonts | None = None
    id: Annotated[
        BrandId, Field(description='Brand identifier within the house. House chooses this ID.')
    ]
    industry: Annotated[
        str | None, Field(description="Industry or vertical (e.g., 'retail', 'automotive', 'cpg')")
    ] = None
    keller_type: KellerType | None = None
    logos: Annotated[list[Logo] | None, Field(description='Brand logo assets')] = None
    names: Annotated[
        list[LocalizedName],
        Field(
            description='Localized brand names. Multiple entries per language allowed for aliases.',
            min_length=1,
        ),
    ]
    parent_brand: Annotated[
        BrandId | None, Field(description='Parent brand ID for sub-brands and endorsed brands')
    ] = None
    privacy_policy_url: Annotated[
        AnyUrl | None, Field(description="URL to the brand's privacy policy")
    ] = None
    product_catalog: ProductCatalog | None = None
    properties: Annotated[
        list[Property] | None, Field(description='Digital properties owned by this brand')
    ] = None
    tagline: Annotated[str | None, Field(description='Brand tagline or slogan')] = None
    target_audience: Annotated[str | None, Field(description='Primary target audience')] = None
    tone: Annotated[
        str | Tone | None, Field(description='Brand voice and messaging tone guidelines')
    ] = None
    voice: Annotated[Voice | None, Field(description='TTS voice configuration')] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 assets : list[Asset] | None

var avatar : Avatar | None

var brand_agent : BrandAgent | None

var colors : Colors | None

var description : str | None

var disclaimers : list[Disclaimer] | None

var fonts : Fonts | None

var id : BrandId

var industry : str | None

var keller_type : KellerType | None

var logos : list[Logo] | None

var model_config

var names : list[LocalizedName]

var parent_brand : BrandId | None

var privacy_policy_url : pydantic.networks.AnyUrl | None

var product_catalog : ProductCatalog | None

var properties : list[Property] | None

var tagline : str | None

var target_audience : str | None

var tone : str | Tone | None

var voice : Voice | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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

Expand source code

class Brand1(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 BrandAgent (**data: Any)

Expand source code

class BrandAgent(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    id: Annotated[
        str,
        Field(
            description='Agent identifier (useful for logging, multi-tenant DAMs)',
            pattern='^[a-z0-9_]+$',
        ),
    ]
    url: Annotated[AnyUrl, Field(description='Brand agent MCP endpoint URL')]

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 id : str

var model_config

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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

Expand source code

class BrandDiscovery(
    RootModel[BrandDiscovery1 | BrandDiscovery2 | BrandDiscovery3 | BrandDiscovery4]
):
    root: Annotated[
        BrandDiscovery1 | BrandDiscovery2 | BrandDiscovery3 | BrandDiscovery4,
        Field(
            description='Brand identity and discovery file. Hosted at /.well-known/brand.json on house domains. Contains the full brand portfolio with identity, creative assets, and digital properties. Brands are identified by house + brand_id (like properties are identified by publisher + property_id). Supports variants: house portfolio (full brand data), brand agent (agent provides brand info via MCP), house redirect (pointer to house domain), or authoritative location redirect.',
            examples=[
                {
                    '$schema': '/schemas/3.0.0-beta.3/brand.json',
                    'authoritative_location': 'https://adcontextprotocol.org/brand/abc123/brand.json',
                },
                {
                    '$schema': '/schemas/3.0.0-beta.3/brand.json',
                    'house': 'nikeinc.com',
                    'note': 'Redirect to house domain for full brand portfolio',
                },
                {
                    '$schema': '/schemas/3.0.0-beta.3/brand.json',
                    'brand_agent': {'id': 'acme_brand_agent', 'url': 'https://agent.acme.com/mcp'},
                    'version': '1.0',
                },
                {
                    '$schema': '/schemas/3.0.0-beta.3/brand.json',
                    'brands': [
                        {
                            'colors': {'primary': '#FF6600', 'secondary': '#0066CC'},
                            'description': 'Laundry detergent brand',
                            'id': 'tide',
                            'industry': 'cpg',
                            'keller_type': 'master',
                            'logos': [
                                {
                                    'tags': ['square', 'primary'],
                                    'url': 'https://cdn.pg.com/tide/logo-square.png',
                                }
                            ],
                            'names': [{'en': 'Tide'}, {'es': 'Tide'}, {'zh': '汰渍'}],
                            'properties': [
                                {'identifier': 'tide.com', 'primary': True, 'type': 'website'},
                                {
                                    'identifier': 'com.pg.tide',
                                    'store': 'apple',
                                    'type': 'mobile_app',
                                },
                            ],
                            'tagline': "Tide's In, Dirt's Out",
                            'tone': {
                                'attributes': ['reliable', 'family-friendly', 'confident'],
                                'donts': ['Avoid technical jargon', "Don't be overly serious"],
                                'dos': ['Use simple, direct language', 'Emphasize cleaning power'],
                                'voice': 'clean, fresh, trustworthy',
                            },
                        },
                        {
                            'colors': {'primary': '#00A0D2'},
                            'id': 'pampers',
                            'industry': 'cpg',
                            'keller_type': 'master',
                            'logos': [
                                {'tags': ['primary'], 'url': 'https://cdn.pg.com/pampers/logo.png'}
                            ],
                            'names': [{'en': 'Pampers'}],
                            'properties': [
                                {'identifier': 'pampers.com', 'primary': True, 'type': 'website'}
                            ],
                        },
                    ],
                    'contact': {'email': 'brands@pg.com', 'name': 'P&G Brand Team'},
                    'house': {
                        'architecture': 'house_of_brands',
                        'domain': 'pg.com',
                        'name': 'Procter & Gamble',
                    },
                    'last_updated': '2026-01-15T10:00:00Z',
                    'version': '1.0',
                },
                {
                    '$schema': '/schemas/3.0.0-beta.3/brand.json',
                    'authorized_operators': [
                        {
                            'brands': ['nike', 'air_jordan'],
                            'countries': ['US', 'GB', 'DE', 'FR'],
                            'domain': 'wpp.com',
                        },
                        {'brands': ['nike'], 'countries': ['JP'], 'domain': 'dentsu.co.jp'},
                        {'brands': ['*'], 'domain': 'nike.com'},
                    ],
                    'brands': [
                        {
                            'colors': {'accent': '#FF6600', 'primary': '#111111'},
                            'id': 'nike',
                            'keller_type': 'master',
                            'logos': [
                                {
                                    'tags': ['dark', 'icon'],
                                    'url': 'https://cdn.nike.com/swoosh-dark.svg',
                                },
                                {
                                    'tags': ['full', 'horizontal'],
                                    'url': 'https://cdn.nike.com/logo-full.svg',
                                },
                            ],
                            'names': [{'en': 'Nike'}, {'zh': '耐克'}, {'ja': 'ナイキ'}],
                            'properties': [
                                {'identifier': 'nike.com', 'primary': True, 'type': 'website'},
                                {'identifier': 'nike.cn', 'region': 'CN', 'type': 'website'},
                                {
                                    'identifier': 'com.nike.omega',
                                    'store': 'apple',
                                    'type': 'mobile_app',
                                },
                            ],
                            'tagline': 'Just Do It',
                            'tone': 'inspirational, bold, athletic',
                        },
                        {
                            'brand_agent': {'id': 'nike_dam', 'url': 'https://dam.nike.com/mcp'},
                            'colors': {'primary': '#CE1141', 'secondary': '#111111'},
                            'id': 'air_jordan',
                            'keller_type': 'endorsed',
                            'logos': [
                                {'tags': ['icon'], 'url': 'https://cdn.nike.com/jumpman.svg'}
                            ],
                            'names': [{'en': 'Air Jordan'}, {'en': 'Jordan'}, {'en': 'Jumpman'}],
                            'parent_brand': 'nike',
                            'properties': [
                                {'identifier': 'jordan.com', 'primary': True, 'type': 'website'},
                                {'identifier': 'jumpman23.com', 'type': 'website'},
                            ],
                        },
                        {
                            'id': 'converse',
                            'keller_type': 'independent',
                            'logos': [
                                {'tags': ['icon'], 'url': 'https://cdn.converse.com/star.svg'}
                            ],
                            'names': [{'en': 'Converse'}],
                            'properties': [
                                {'identifier': 'converse.com', 'primary': True, 'type': 'website'}
                            ],
                        },
                    ],
                    'house': {
                        'architecture': 'hybrid',
                        'domain': 'nikeinc.com',
                        'name': 'Nike, Inc.',
                    },
                    'last_updated': '2026-01-15T10:00:00Z',
                    'version': '1.0',
                },
            ],
            title='Brand Discovery',
        ),
    ]

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[BrandDiscovery1, BrandDiscovery2, BrandDiscovery3, BrandDiscovery4]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var root : BrandDiscovery1 | BrandDiscovery2 | BrandDiscovery3 | BrandDiscovery4

class BrandDiscovery1 (**data: Any)

Expand source code

class BrandDiscovery1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    field_schema: Annotated[str | None, Field(alias='$schema')] = None
    authoritative_location: Annotated[
        AnyUrl, Field(description='HTTPS URL of the authoritative brand.json file')
    ]
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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

Expand source code

class BrandDiscovery2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    field_schema: Annotated[str | None, Field(alias='$schema')] = None
    house: Annotated[Domain, Field(description='House domain to fetch brand portfolio from')]
    last_updated: AwareDatetime | None = None
    note: str | None = None
    region: Annotated[
        str | None,
        Field(
            description='ISO 3166-1 alpha-2 country code if this is a regional domain',
            pattern='^[A-Z]{2}$',
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 field_schema : str | None

var house : Domain

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var note : str | None

var region : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class BrandDiscovery3 (**data: Any)

Expand source code

class BrandDiscovery3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    field_schema: Annotated[str | None, Field(alias='$schema')] = None
    brand_agent: BrandAgent
    contact: Contact | None = None
    last_updated: AwareDatetime | None = None
    version: str | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 brand_agent : BrandAgent

var contact : Contact | None

var field_schema : str | None

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var version : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class BrandDiscovery4 (**data: Any)

Expand source code

class BrandDiscovery4(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    field_schema: Annotated[str | None, Field(alias='$schema')] = None
    authorized_operators: Annotated[
        list[AuthorizedOperator] | None,
        Field(
            description="Entities authorized to represent brands from this house. Third parties (sellers, platforms) can verify an operator's authorization by checking this list. Operators are identified by domain."
        ),
    ] = None
    brands: Annotated[list[Brand], Field(description='Brands owned by this house', min_length=1)]
    contact: Contact | None = None
    house: House
    last_updated: AwareDatetime | None = None
    trademarks: list[Trademark] | None = None
    version: str | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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_operators : list[AuthorizedOperator] | None

var brands : list[Brand]

var contact : Contact | None

var field_schema : str | None

var house : House

var last_updated : pydantic.types.AwareDatetime | None

var model_config

var trademarks : list[Trademark] | None

var version : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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

Expand source code

class BrandId(RootModel[str]):
    root: Annotated[
        str,
        Field(
            description='Brand identifier within the house portfolio. Lowercase alphanumeric with underscores. House chooses this ID.',
            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 ColorValue (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class ColorValue(RootModel[ColorValue1 | ColorValue2]):
    root: ColorValue1 | ColorValue2

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

Class variables

var model_config

var root : ColorValue1 | ColorValue2

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

Expand source code

class ColorValue1(RootModel[str]):
    root: Annotated[str, Field(pattern='^#[0-9A-Fa-f]{6}$')]

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

Subclasses

• ColorValue2Item

Class variables

var model_config

var root : str

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

Expand source code

class ColorValue2(RootModel[list[ColorValue2Item]]):
    root: Annotated[list[ColorValue2Item], Field(min_length=1)]

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

Class variables

var model_config

var root : list[ColorValue2Item]

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

Expand source code

class ColorValue2Item(ColorValue1):
    pass

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

• ColorValue1
• pydantic.root_model.RootModel[str]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

class Colors (**data: Any)

Expand source code

class Colors(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    accent: ColorValue | None = None
    background: ColorValue | None = None
    primary: ColorValue | None = None
    secondary: ColorValue | None = None
    text: ColorValue | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 accent : ColorValue | None

var background : ColorValue | None

var model_config

var primary : ColorValue | None

var secondary : ColorValue | None

var text : ColorValue | None

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',
    )
    domain: Domain | None = None
    email: Annotated[EmailStr | None, Field(max_length=255)] = None
    name: Annotated[str, Field(max_length=255, min_length=1)]

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 : Domain | None

var email : pydantic.networks.EmailStr | None

var model_config

var name : str

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

Expand source code

class Disclaimer(AdCPBaseModel):
    context: str | None = None
    required: bool | None = True
    text: str

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 context : str | None

var model_config

var required : bool | None

var text : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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

Expand source code

class Domain(RootModel[str]):
    root: Annotated[
        str,
        Field(
            description='A valid domain name',
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[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 FeedFormat (*args, **kwds)

Expand source code

class FeedFormat(Enum):
    google_merchant_center = 'google_merchant_center'
    facebook_catalog = 'facebook_catalog'
    openai_product_feed = 'openai_product_feed'
    custom = 'custom'

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 custom

var facebook_catalog

var google_merchant_center

var openai_product_feed

class Fonts (**data: Any)

Expand source code

class Fonts(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    font_urls: Annotated[list[AnyUrl] | None, Field(description='URLs to web font files')] = None
    primary: Annotated[str | None, Field(description='Primary font family')] = None
    secondary: Annotated[str | None, Field(description='Secondary font family')] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 font_urls : list[pydantic.networks.AnyUrl] | None

var model_config

var primary : str | None

var secondary : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class House (**data: Any)

Expand source code

class House(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    architecture: Annotated[
        Architecture | None,
        Field(
            description='Brand architecture model: branded_house (Google), house_of_brands (P&G), hybrid (Nike)'
        ),
    ] = None
    domain: Annotated[Domain, Field(description="The house's domain where brand.json is hosted")]
    name: Annotated[str, Field(description='Primary display name of the house', min_length=1)]
    names: Annotated[
        list[LocalizedName] | None,
        Field(description='Localized house names including legal name, stock symbol, etc.'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 architecture : Architecture | None

var domain : Domain

var model_config

var name : str

var names : list[LocalizedName] | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class KellerType (*args, **kwds)

Expand source code

class KellerType(Enum):
    master = 'master'
    sub_brand = 'sub_brand'
    endorsed = 'endorsed'
    independent = 'independent'

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

• attribute access::

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

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

>>> len(Color)
3

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

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

Ancestors

• enum.Enum

Class variables

var endorsed

var independent

var master

var sub_brand

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

Expand source code

class LocalizedName(RootModel[dict[str, str]]):
    root: Annotated[dict[str, str], Field(min_length=1)]

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

Class variables

var model_config

var root : dict[str, str]

class Logo (**data: Any)

Expand source code

class Logo(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    height: Annotated[int | None, Field(description='Height in pixels')] = None
    tags: Annotated[
        list[str] | None,
        Field(description="Semantic tags (e.g., 'dark', 'light', 'square', 'horizontal', 'icon')"),
    ] = None
    url: Annotated[AnyUrl, Field(description='URL to the logo asset')]
    width: Annotated[int | None, Field(description='Width in pixels')] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 height : int | None

var model_config

var tags : list[str] | None

var url : pydantic.networks.AnyUrl

var width : int | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class ProductCatalog (**data: Any)

Expand source code

class ProductCatalog(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    agentic_checkout: AgenticCheckout | None = None
    categories: list[str] | None = None
    feed_format: FeedFormat | None = None
    feed_url: AnyUrl
    update_frequency: UpdateFrequency | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 agentic_checkout : AgenticCheckout | None

var categories : list[str] | None

var feed_format : FeedFormat | None

var feed_url : pydantic.networks.AnyUrl

var model_config

var update_frequency : UpdateFrequency | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Property (**data: Any)

Expand source code

class Property(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    identifier: Annotated[
        str,
        Field(
            description='Property identifier - domain for websites, bundle ID for apps',
            min_length=1,
        ),
    ]
    primary: Annotated[
        bool | None, Field(description='Whether this is the primary property for the brand')
    ] = False
    region: Annotated[
        str | None,
        Field(
            description="ISO 3166-1 alpha-2 country code or 'global'", pattern='^([A-Z]{2}|global)$'
        ),
    ] = None
    store: Annotated[Store | None, Field(description='App store for mobile/CTV apps')] = None
    type: Annotated[Type, Field(description='Property type')]

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 identifier : str

var model_config

var primary : bool | None

var region : str | None

var store : Store | None

var type : Type

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Store (*args, **kwds)

Expand source code

class Store(Enum):
    apple = 'apple'
    google = 'google'
    amazon = 'amazon'
    roku = 'roku'
    samsung = 'samsung'
    lg = 'lg'
    other = 'other'

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

• attribute access::

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

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

>>> len(Color)
3

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

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

Ancestors

• enum.Enum

Class variables

var amazon

var apple

var google

var lg

var other

var roku

var samsung

class Tone (**data: Any)

Expand source code

class Tone(AdCPBaseModel):
    attributes: Annotated[
        list[str] | None, Field(description='Personality traits that characterize the brand voice')
    ] = None
    donts: Annotated[
        list[str] | None, Field(description='Guardrails to avoid brand violations - what NOT to do')
    ] = None
    dos: Annotated[
        list[str] | None, Field(description='Guidance for copy generation - what TO do')
    ] = None
    voice: Annotated[
        str | None,
        Field(
            description="High-level voice descriptor (e.g., 'warm and inviting', 'professional and trustworthy')"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 attributes : list[str] | None

var donts : list[str] | None

var dos : list[str] | None

var model_config

var voice : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Trademark (**data: Any)

Expand source code

class Trademark(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    mark: str
    number: str
    registry: str

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 mark : str

var model_config

var number : str

var registry : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Type (*args, **kwds)

Expand source code

class Type(Enum):
    website = 'website'
    mobile_app = 'mobile_app'
    ctv_app = 'ctv_app'
    desktop_app = 'desktop_app'
    dooh = 'dooh'
    podcast = 'podcast'
    radio = 'radio'
    streaming_audio = 'streaming_audio'

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 ctv_app

var desktop_app

var dooh

var mobile_app

var podcast

var radio

var streaming_audio

var website

class UpdateFrequency (*args, **kwds)

Expand source code

class UpdateFrequency(Enum):
    realtime = 'realtime'
    hourly = 'hourly'
    daily = 'daily'
    weekly = 'weekly'

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 daily

var hourly

var realtime

var weekly

class Voice (**data: Any)

Expand source code

class Voice(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    provider: str | None = None
    settings: dict[str, Any] | None = None
    voice_id: str | None = None

Base model for AdCP types with spec-compliant serialization.

AdCP JSON schemas use additionalProperties: false and do not allow null for optional fields. Therefore, optional fields must be omitted entirely when not present (not sent as null).

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 model_config

var provider : str | None

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

var voice_id : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary