Module `adcp.types.generated_poc.brand`

Sub-modules

adcp.types.generated_poc.brand.acquire_rights_request
adcp.types.generated_poc.brand.acquire_rights_response
adcp.types.generated_poc.brand.get_brand_identity_request
adcp.types.generated_poc.brand.get_brand_identity_response
adcp.types.generated_poc.brand.get_rights_request
adcp.types.generated_poc.brand.get_rights_response
adcp.types.generated_poc.brand.rights_pricing_option
adcp.types.generated_poc.brand.rights_terms

Classes

class AgenticCheckout (**data: Any)

Expand source code

class AgenticCheckout(AdCPBaseModel):
    endpoint: Annotated[AnyUrl, Field(description='Base URL for checkout session API')]
    spec: Annotated[
        Literal['openai_agentic_checkout_v1'], Field(description='Checkout API specification')
    ]
    supported_payment_providers: Annotated[
        list[str] | None, Field(description='Payment providers supported by this checkout endpoint')
    ] = 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 endpoint : pydantic.networks.AnyUrl
var model_config
var spec : Literal['openai_agentic_checkout_v1']
var supported_payment_providers : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AnimationSpeed (*args, **kwds)

Expand source code

class AnimationSpeed(Enum):
    slow = 'slow'
    moderate = 'moderate'
    fast = 'fast'

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 fast
var moderate
var slow

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[
        asset_content_type.AssetContentType, Field(description='Type of asset content')
    ]
    description: Annotated[str | None, Field(description='Asset description or usage notes')] = None
    duration_seconds: Annotated[
        float | None, Field(description='Video/audio duration in seconds')
    ] = None
    file_size_bytes: Annotated[int | None, Field(description='File size in bytes')] = None
    format: Annotated[str | None, Field(description="File format (e.g., 'jpg', 'mp4', 'mp3')")] = (
        None
    )
    height: Annotated[int | None, Field(description='Image/video height in pixels')] = None
    metadata: Annotated[
        dict[str, Any] | None, Field(description='Additional asset-specific metadata')
    ] = 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', 'holiday')"),
    ] = None
    url: Annotated[AnyUrl, Field(description='URL to CDN-hosted asset file')]
    width: Annotated[int | None, Field(description='Image/video width in pixels')] = None

Base model for AdCP types with spec-compliant serialization.

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 : AssetContentType
var description : str | None
var duration_seconds : float | None
var file_size_bytes : int | None
var format : str | None
var height : int | None
var metadata : dict[str, typing.Any] | 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 AssetLibrary (**data: Any)

Expand source code

class AssetLibrary(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    color_guide: Annotated[
        ColorGuide | None,
        Field(description='Color guide for the asset library defining roles and palettes'),
    ] = None
    description: Annotated[
        str | None, Field(description='Description of the library contents and usage')
    ] = None
    name: Annotated[str, Field(description='Display name of the asset library')]
    type: Annotated[Type | None, Field(description='Type of asset library')] = None
    url: Annotated[AnyUrl, Field(description='URL to the asset library (for human access)')]

Base model for AdCP types with spec-compliant serialization.

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 color_guide : ColorGuide | None
var description : str | None
var model_config
var name : str
var type : Type | None
var url : pydantic.networks.AnyUrl

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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.

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.

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

Expand source code

class Background(Enum):
    dark_bg = 'dark-bg'
    light_bg = 'light-bg'
    transparent_bg = 'transparent-bg'

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 dark_bg
var light_bg
var transparent_bg

class BackgroundContrast (*args, **kwds)

Expand source code

class BackgroundContrast(Enum):
    light_only = 'light_only'
    dark_only = 'dark_only'
    any = 'any'

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 any
var dark_only
var light_only

class Backgrounds (**data: Any)

Expand source code

class Backgrounds(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    types_allowed: Annotated[
        list[TypesAllowedEnum] | None, Field(description='Permitted background types')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 types_allowed : list[TypesAllowedEnum] | 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 data via MCP')
    ] = None
    collections: Annotated[
        list[Collection] | None,
        Field(
            description="Collections this person or brand is associated with. Enables bidirectional linking: a collection's talent references brand.json via brand_url, and brand.json links back to collections."
        ),
    ] = None
    colors: Colors | None = None
    contact: Annotated[Contact1 | None, Field(description='Brand-level contact information')] = 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.')
    ]
    industries: Annotated[
        list[advertiser_industry.AdvertiserIndustry] | None,
        Field(
            description="Brand industries (e.g., ['automotive'] or ['healthcare.pharmaceutical', 'cpg'] for a consumer health company). Describes what the company does — not what regulatory regimes apply (use policy_categories for that). When create_media_buy omits advertiser_industry, sellers may infer from this field.",
            min_length=1,
        ),
    ] = 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
    rights_agent: Annotated[
        RightsAgent | None, Field(description='Rights licensing agent for this brand')
    ] = None
    tagline: Annotated[
        str | Tagline | None,
        Field(
            description='Brand tagline or slogan. Accepts a plain string or a localized array matching the names pattern.'
        ),
    ] = 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
    url: Annotated[
        AnyUrl | None, Field(description='Primary brand URL for context and asset discovery')
    ] = None
    visual_guidelines: Annotated[
        VisualGuidelines | None,
        Field(description='Structured visual rules for generative creative systems'),
    ] = None
    voice_synthesis: Annotated[
        VoiceSynthesis | None,
        Field(description='TTS voice synthesis configuration for AI-generated audio'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 collections : list[Collection] | None
var colors : Colors | None
var contact : Contact1 | None
var description : str | None
var disclaimers : list[Disclaimer] | None
var fonts : Fonts | None
var id : BrandId
var industries : list[AdvertiserIndustry] | 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 rights_agent : RightsAgent | None
var tagline : str | Tagline | None
var target_audience : str | None
var tone : str | Tone | None
var url : pydantic.networks.AnyUrl | None
var visual_guidelines : VisualGuidelines | None
var voice_synthesis : VoiceSynthesis | 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.

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-rc.3/brand.json',
                    'authoritative_location': 'https://adcontextprotocol.org/brand/abc123/brand.json',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/brand.json',
                    'house': 'nikeinc.com',
                    'note': 'Redirect to house domain for full brand portfolio',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/brand.json',
                    'brand_agent': {'id': 'acme_brand_agent', 'url': 'https://agent.acme.com/mcp'},
                    'version': '1.0',
                },
                {
                    '$schema': '/schemas/3.0.0-rc.3/brand.json',
                    'brands': [
                        {
                            'colors': {'primary': '#FF6600', 'secondary': '#0066CC'},
                            'contact': {'email': 'brands@pg.com'},
                            'description': 'Laundry detergent brand',
                            'id': 'tide',
                            'industries': ['cpg'],
                            'keller_type': 'master',
                            'logos': [
                                {
                                    'background': 'transparent-bg',
                                    'orientation': 'square',
                                    'url': 'https://cdn.pg.com/tide/logo-square.png',
                                    'usage': 'Primary logo for general use',
                                    'variant': 'primary',
                                },
                                {
                                    'background': 'dark-bg',
                                    'orientation': 'horizontal',
                                    'url': 'https://cdn.pg.com/tide/logo-horizontal-dark.png',
                                    'usage': 'Full lockup for dark backgrounds',
                                    'variant': 'full-lockup',
                                },
                            ],
                            'names': [{'en_US': 'Tide'}, {'es_MX': 'Tide'}, {'zh_CN': '汰渍'}],
                            'properties': [
                                {'identifier': 'tide.com', 'primary': True, 'type': 'website'},
                                {
                                    'identifier': 'com.pg.tide',
                                    'store': 'apple',
                                    'type': 'mobile_app',
                                },
                            ],
                            'tagline': [{'en_US': "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',
                            },
                            'url': 'https://tide.com',
                            'visual_guidelines': {
                                'colorways': [
                                    {
                                        'accent': '#0066CC',
                                        'background': '#FF6600',
                                        'foreground': '#FFFFFF',
                                        'name': 'primary',
                                    },
                                    {
                                        'accent': '#0066CC',
                                        'background': '#FFFFFF',
                                        'border': '#FF6600',
                                        'foreground': '#FF6600',
                                        'name': 'inverted',
                                    },
                                ],
                                'composition': {
                                    'backgrounds': {
                                        'types_allowed': [
                                            'solid_color',
                                            'gradient',
                                            'blurred_photo',
                                        ]
                                    },
                                    'overlays': {
                                        'gradient_direction': '180deg',
                                        'gradient_style': 'linear',
                                        'opacity': '60%',
                                    },
                                    'texture': {'style': 'none'},
                                },
                                'graphic_style': {
                                    'corner_radius': '12px',
                                    'stroke_style': 'rounded',
                                    'stroke_weight': '2px',
                                    'style_type': 'flat_illustration',
                                },
                                'iconography': {
                                    'corner_style': 'rounded',
                                    'stroke_weight': '2px',
                                    'style': 'outline',
                                    'usage': {'max_per_frame': 3, 'size_ratio': '1:8'},
                                },
                                'logo_placement': {
                                    'background_contrast': 'any',
                                    'min_clear_space': '0.5x',
                                    'min_height': '32px',
                                    'preferred_position': 'bottom-right',
                                },
                                'motion': {
                                    'animation_speed': 'moderate',
                                    'easing': 'ease-in-out',
                                    'kinetic_typography': False,
                                    'pacing': 'moderate',
                                    'text_entrance': 'fade',
                                    'transition_style': 'dissolve',
                                },
                                'photography': {
                                    'color_temperature': 'warm',
                                    'contrast': 'medium',
                                    'depth_of_field': 'medium',
                                    'framing': {
                                        'crop_style': 'waist-up',
                                        'perspective': 'eye-level',
                                        'subject_position': 'center',
                                    },
                                    'lighting': 'soft daylight',
                                    'preferred_aspect_ratios': ['16:9', '4:5', '1:1'],
                                    'realism': 'natural',
                                    'subject': {
                                        'people': {
                                            'age_range': '25-45',
                                            'diversity': 'mixed',
                                            'mood': ['confident', 'relaxed', 'happy'],
                                        },
                                        'product_focus': 'in-use',
                                        'setting': 'indoor',
                                    },
                                },
                                'restrictions': [
                                    'Never place text over the product',
                                    'Do not use black backgrounds',
                                    'No stock photography of people on phones',
                                ],
                                'shapes': {
                                    'primary_shape': 'circle',
                                    'secondary_shapes': ['rounded_rectangle'],
                                    'usage': {'max_per_layout': 2, 'overlap_allowed': False},
                                },
                                'type_scale': {
                                    'base_width': '1080px',
                                    'body': {
                                        'font': 'secondary',
                                        'line_height': '1.5',
                                        'size': '16px',
                                        'weight': '400',
                                    },
                                    'cta': {
                                        'font': 'primary',
                                        'letter_spacing': '0.05em',
                                        'size': '18px',
                                        'text_transform': 'uppercase',
                                        'weight': '700',
                                    },
                                    'heading': {
                                        'font': 'primary',
                                        'line_height': '1.1',
                                        'size': '48px',
                                        'text_transform': 'none',
                                        'weight': '700',
                                    },
                                    'subheading': {
                                        'font': 'primary',
                                        'line_height': '1.3',
                                        'size': '24px',
                                        'weight': '600',
                                    },
                                },
                            },
                        },
                        {
                            'colors': {'primary': '#00A0D2'},
                            'id': 'pampers',
                            'industries': ['cpg'],
                            'keller_type': 'master',
                            'logos': [
                                {
                                    'orientation': 'horizontal',
                                    'url': 'https://cdn.pg.com/pampers/logo.png',
                                    'variant': 'primary',
                                }
                            ],
                            'names': [{'en_US': 'Pampers'}],
                            'properties': [
                                {'identifier': 'pampers.com', 'primary': True, 'type': 'website'}
                            ],
                            'url': 'https://pampers.com',
                        },
                    ],
                    '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-rc.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': [
                                {
                                    'background': 'dark-bg',
                                    'orientation': 'horizontal',
                                    'url': 'https://cdn.nike.com/swoosh-dark.svg',
                                    'usage': 'Swoosh icon for dark backgrounds',
                                    'variant': 'icon',
                                },
                                {
                                    'background': 'light-bg',
                                    'orientation': 'horizontal',
                                    'url': 'https://cdn.nike.com/logo-full.svg',
                                    'usage': 'Full logo with wordmark for light backgrounds',
                                    'variant': 'full-lockup',
                                },
                            ],
                            'names': [{'en_US': 'Nike'}, {'zh_CN': '耐克'}, {'ja_JP': 'ナイキ'}],
                            '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': [{'en_US': 'Just Do It'}],
                            'tone': 'inspirational, bold, athletic',
                            'url': 'https://nike.com',
                        },
                        {
                            'brand_agent': {'id': 'nike_dam', 'url': 'https://dam.nike.com/mcp'},
                            'colors': {'primary': '#CE1141', 'secondary': '#111111'},
                            'id': 'air_jordan',
                            'keller_type': 'endorsed',
                            'logos': [
                                {
                                    'background': 'transparent-bg',
                                    'orientation': 'square',
                                    'url': 'https://cdn.nike.com/jumpman.svg',
                                    'variant': 'icon',
                                }
                            ],
                            'names': [
                                {'en_US': 'Air Jordan'},
                                {'en_US': 'Jordan'},
                                {'en_US': 'Jumpman'},
                            ],
                            'parent_brand': 'nike',
                            'properties': [
                                {'identifier': 'jordan.com', 'primary': True, 'type': 'website'},
                                {'identifier': 'jumpman23.com', 'type': 'website'},
                            ],
                            'url': 'https://jordan.com',
                        },
                        {
                            'id': 'converse',
                            'keller_type': 'independent',
                            'logos': [
                                {
                                    'orientation': 'square',
                                    'url': 'https://cdn.converse.com/star.svg',
                                    'variant': 'icon',
                                }
                            ],
                            'names': [{'en_US': 'Converse'}],
                            'properties': [
                                {'identifier': 'converse.com', 'primary': True, 'type': 'website'}
                            ],
                            'url': 'https://converse.com',
                        },
                    ],
                    'house': {
                        'architecture': 'hybrid',
                        'domain': 'nikeinc.com',
                        'name': 'Nike, Inc.',
                    },
                    'last_updated': '2026-01-15T10:00:00Z',
                    'version': '1.0',
                },
            ],
            title='Brand Discovery',
        ),
    ]

    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[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.

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.

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.

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.

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

Expand source code

class BrandShapes(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    primary_shape: Annotated[
        str | None,
        Field(description="Primary brand shape (e.g., 'rounded_rectangle', 'circle', 'hexagon')"),
    ] = None
    secondary_shapes: Annotated[
        list[str] | None, Field(description='Secondary shapes in the brand vocabulary')
    ] = None
    usage: Annotated[Usage | None, Field(description='Shape usage rules')] = None

Base model for AdCP types with spec-compliant serialization.

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 primary_shape : str | None
var secondary_shapes : list[str] | None
var usage : Usage | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Collection (**data: Any)

Expand source code

class Collection(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    collection_id: Annotated[
        str | None,
        Field(description="Collection identifier as used in the seller's get_products responses"),
    ] = None
    name: Annotated[str, Field(description='Human-readable collection name')]
    role: Annotated[
        talent_role.TalentRole | None, Field(description="This person's role on the collection")
    ] = None
    seller_agent_url: Annotated[
        AnyUrl | None,
        Field(
            description='URL of the sales agent that sells inventory for this collection. Buyer agents can query this agent for collection products.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 collection_id : str | None
var model_config
var name : str
var role : TalentRole | None
var seller_agent_url : pydantic.networks.AnyUrl | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ColorGuide (**data: Any)

Expand source code

class ColorGuide(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    palettes: Annotated[
        list[Palette] | None,
        Field(description='Named color palettes mapping roles to specific colors'),
    ] = None
    roles: Annotated[
        list[str] | None,
        Field(
            description='Named color roles used in the library (e.g., base, shadow_1, highlight_1, stroke)'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 palettes : list[Palette] | None
var roles : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ColorTemperature (*args, **kwds)

Expand source code

class ColorTemperature(Enum):
    warm = 'warm'
    neutral = 'neutral'
    cool = 'cool'

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 cool
var neutral
var warm

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

Expand source code

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

    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[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.

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

Expand source code

class Colorway(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    accent: HexColor | None = None
    background: HexColor
    border: HexColor | None = None
    channels: Annotated[
        list[str] | None,
        Field(
            description="Channels or contexts where this colorway applies (e.g., 'online', 'print', 'pos', 'social', 'outdoor'). Omit for universal colorways."
        ),
    ] = None
    cta_background: Annotated[
        HexColor | None, Field(description='CTA button/container color, if different from accent')
    ] = None
    cta_foreground: Annotated[
        HexColor | None, Field(description='CTA text/icon color, if different from foreground')
    ] = None
    foreground: HexColor
    name: Annotated[str, Field(description="Colorway name (e.g., 'primary', 'inverted', 'subtle')")]

Base model for AdCP types with spec-compliant serialization.

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 : HexColor | None
var background : HexColor
var border : HexColor | None
var channels : list[str] | None
var cta_background : HexColor | None
var cta_foreground : HexColor | None
var foreground : HexColor
var model_config
var name : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CompositionRules (**data: Any)

Expand source code

class CompositionRules(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    backgrounds: Annotated[Backgrounds | None, Field(description='Background treatment rules')] = (
        None
    )
    overlays: Annotated[Overlays | None, Field(description='Graphic overlay rules')] = None
    texture: Annotated[Texture | None, Field(description='Texture treatment rules')] = None

Base model for AdCP types with spec-compliant serialization.

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 backgrounds : Backgrounds | None
var model_config
var overlays : Overlays | None
var texture : Texture | 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.

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

Expand source code

class Contact1(AdCPBaseModel):
    email: Annotated[EmailStr | None, Field(description='Contact email')] = None
    phone: Annotated[str | None, Field(description='Contact phone number')] = None

Base model for AdCP types with spec-compliant serialization.

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 email : pydantic.networks.EmailStr | None
var model_config
var phone : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class CornerStyle (*args, **kwds)

Expand source code

class CornerStyle(Enum):
    rounded = 'rounded'
    square = 'square'
    mixed = 'mixed'

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 mixed
var rounded
var square

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

Expand source code

class DepthOfField(Enum):
    shallow = 'shallow'
    medium = 'medium'
    deep = 'deep'

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 deep
var medium
var shallow

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.

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.

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

Expand source code

class Framing(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    crop_style: Annotated[
        str | None,
        Field(
            description="Cropping convention (e.g., 'waist-up', 'full-body', 'close-up', 'wide')"
        ),
    ] = None
    perspective: Annotated[
        str | None,
        Field(description="Camera perspective (e.g., 'eye-level', 'overhead', 'low-angle')"),
    ] = None
    subject_position: Annotated[
        str | None,
        Field(
            description="Where the subject sits in frame (e.g., 'center', 'center-left', 'rule-of-thirds')"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 crop_style : str | None
var model_config
var perspective : str | None
var subject_position : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GradientStyle (*args, **kwds)

Expand source code

class GradientStyle(Enum):
    linear = 'linear'
    radial = 'radial'
    conic = 'conic'
    none = 'none'

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

attribute access::

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

value lookup:

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

name lookup:

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

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

>>> len(Color)
3

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

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

Ancestors

enum.Enum

Class variables

var conic
var linear
var none
var radial

class GraphicElement (**data: Any)

Expand source code

class GraphicElement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    colors: Annotated[
        list[HexColor] | None, Field(description='Colors this element may appear in')
    ] = None
    description: Annotated[str | None, Field(description='How the element is used in layouts')] = (
        None
    )
    max_per_layout: Annotated[int | None, Field(description='Maximum instances per layout')] = None
    name: Annotated[
        str,
        Field(
            description="Element name (e.g., 'Paper Tear', 'Brand Watermark', 'Section Divider')"
        ),
    ]
    orientation: Annotated[
        Orientation | None, Field(description='Preferred orientation when used in layouts')
    ] = None
    type: Annotated[Type1 | None, Field(description='Element type')] = None

Base model for AdCP types with spec-compliant serialization.

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 colors : list[HexColor] | None
var description : str | None
var max_per_layout : int | None
var model_config
var name : str
var orientation : Orientation | None
var type : Type1 | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class GraphicStyle (**data: Any)

Expand source code

class GraphicStyle(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    corner_radius: Annotated[
        str | None,
        Field(
            description="Default corner radius for rounded elements (e.g., '12px', '8px', 'sharp')"
        ),
    ] = None
    stroke_style: Annotated[StrokeStyle | None, Field(description='Stroke end/join style')] = None
    stroke_weight: Annotated[
        str | None, Field(description="Stroke weight (e.g., '2px', 'thin', 'bold')")
    ] = None
    style_type: Annotated[StyleType | None, Field(description='Primary graphic style')] = None
    tags: Annotated[list[str] | None, Field(description='Additional style descriptors')] = None

Base model for AdCP types with spec-compliant serialization.

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 corner_radius : str | None
var model_config
var stroke_style : StrokeStyle | None
var stroke_weight : str | None
var style_type : StyleType | None
var tags : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class HexColor(RootModel[str]):
    root: Annotated[str, Field(description='A single hex color value', 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

Class variables

var model_config
var root : str

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.

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

Expand source code

class Iconography(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    corner_style: Annotated[
        CornerStyle | None, Field(description='Corner style for icon paths')
    ] = None
    stroke_weight: Annotated[
        str | None, Field(description="Icon stroke weight (e.g., '2px', '1.5px')")
    ] = None
    style: Annotated[Style1 | None, Field(description='Icon rendering style')] = None
    usage: Annotated[Usage1 | None, Field(description='Icon usage rules')] = None

Base model for AdCP types with spec-compliant serialization.

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 corner_style : CornerStyle | None
var model_config
var stroke_weight : str | None
var style : Style1 | None
var usage : Usage1 | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Intensity (*args, **kwds)

Expand source code

class Intensity(Enum):
    low = 'low'
    medium = 'medium'
    high = 'high'

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 high
var low
var medium

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',
    )
    background: Annotated[
        Background | None,
        Field(
            description='Background compatibility. dark-bg: use on dark backgrounds, light-bg: use on light backgrounds, transparent-bg: has transparent background'
        ),
    ] = None
    height: Annotated[int | None, Field(description='Height in pixels')] = None
    orientation: Annotated[
        Orientation1 | None,
        Field(
            description='Logo aspect ratio orientation. square: ~1:1, horizontal: wide, vertical: tall, stacked: vertically arranged elements'
        ),
    ] = None
    tags: Annotated[
        list[str] | None,
        Field(
            description='Additional semantic tags for custom categorization beyond the standard orientation, background, and variant fields'
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description='URL to the logo asset')]
    usage: Annotated[
        str | None,
        Field(
            description="Human-readable description of when to use this logo variant (e.g., 'Primary logo for use on light backgrounds')"
        ),
    ] = None
    variant: Annotated[
        Variant | None,
        Field(
            description='Logo variant type. primary: main logo, secondary: alternative, icon: symbol only, wordmark: text only, full-lockup: complete logo'
        ),
    ] = None
    width: Annotated[int | None, Field(description='Width in pixels')] = None

Base model for AdCP types with spec-compliant serialization.

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 background : Background | None
var height : int | None
var model_config
var orientation : Orientation1 | None
var tags : list[str] | None
var url : pydantic.networks.AnyUrl
var usage : str | None
var variant : Variant | None
var width : int | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class LogoPlacement (**data: Any)

Expand source code

class LogoPlacement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    background_contrast: Annotated[
        BackgroundContrast | None, Field(description='Permitted background contrast behind logo')
    ] = None
    min_clear_space: Annotated[
        str | None,
        Field(
            description="Minimum clear space around the logo, expressed as a multiple of logo height (e.g., '0.5x', '1x') or fixed value (e.g., '16px')"
        ),
    ] = None
    min_height: Annotated[
        str | None,
        Field(description="Minimum logo height to maintain legibility (e.g., '40px', '24px')"),
    ] = None
    preferred_position: Annotated[
        PreferredPosition | None, Field(description='Preferred logo position in layouts')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 background_contrast : BackgroundContrast | None
var min_clear_space : str | None
var min_height : str | None
var model_config
var preferred_position : PreferredPosition | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MotionGuidelines (**data: Any)

Expand source code

class MotionGuidelines(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    animation_speed: Annotated[
        AnimationSpeed | None, Field(description='Overall animation pacing')
    ] = None
    easing: Annotated[
        str | None,
        Field(description="Default easing function (e.g., 'ease-in-out', 'spring', 'linear')"),
    ] = None
    kinetic_typography: Annotated[
        bool | None, Field(description='Whether animated/kinetic typography is allowed')
    ] = None
    pacing: Annotated[Pacing | None, Field(description='Overall editing rhythm')] = None
    tags: Annotated[list[str] | None, Field(description='Additional motion style descriptors')] = (
        None
    )
    text_entrance: Annotated[
        TextEntrance | None, Field(description='How text enters the frame')
    ] = None
    transition_style: Annotated[
        TransitionStyle | None, Field(description='Primary transition style between scenes')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 animation_speed : AnimationSpeed | None
var easing : str | None
var kinetic_typography : bool | None
var model_config
var pacing : Pacing | None
var tags : list[str] | None
var text_entrance : TextEntrance | None
var transition_style : TransitionStyle | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Orientation (*args, **kwds)

Expand source code

class Orientation(Enum):
    horizontal = 'horizontal'
    vertical = 'vertical'
    any = 'any'

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 any
var horizontal
var vertical

class Orientation1 (*args, **kwds)

Expand source code

class Orientation1(Enum):
    square = 'square'
    horizontal = 'horizontal'
    vertical = 'vertical'
    stacked = 'stacked'

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 horizontal
var square
var stacked
var vertical

class Overlays (**data: Any)

Expand source code

class Overlays(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    gradient_direction: Annotated[
        str | None, Field(description="Gradient direction (e.g., '45deg', 'to-bottom-right')")
    ] = None
    gradient_style: Annotated[
        GradientStyle | None, Field(description='Gradient type for overlays')
    ] = None
    opacity: Annotated[str | None, Field(description="Overlay opacity (e.g., '70%')")] = None

Base model for AdCP types with spec-compliant serialization.

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 gradient_direction : str | None
var gradient_style : GradientStyle | None
var model_config
var opacity : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Pacing (*args, **kwds)

Expand source code

class Pacing(Enum):
    lingering = 'lingering'
    moderate = 'moderate'
    fast_cuts = 'fast_cuts'

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 fast_cuts
var lingering
var moderate

class Palette (**data: Any)

Expand source code

class Palette(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    colors: Annotated[
        dict[str, HexColor], Field(description='Map of role names to hex color values')
    ]
    name: Annotated[str, Field(description='Palette name')]

Base model for AdCP types with spec-compliant serialization.

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 colors : dict[str, HexColor]
var model_config
var name : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class People (**data: Any)

Expand source code

class People(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    age_range: Annotated[str | None, Field(description="Target age range (e.g., '20-35')")] = None
    diversity: Annotated[
        str | None, Field(description="Diversity representation (e.g., 'mixed', 'varied')")
    ] = None
    mood: Annotated[
        list[str] | None, Field(description="Mood descriptors (e.g., ['confident', 'relaxed'])")
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 age_range : str | None
var diversity : str | None
var model_config
var mood : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class PhotographyStyle (**data: Any)

Expand source code

class PhotographyStyle(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    color_temperature: Annotated[
        ColorTemperature | None, Field(description='Overall color temperature of photography')
    ] = None
    contrast: Annotated[Intensity | None, Field(description='Contrast level in photography')] = None
    depth_of_field: Annotated[
        DepthOfField | None,
        Field(
            description='Depth of field preference. shallow: blurred background with subject isolation, deep: everything in focus'
        ),
    ] = None
    framing: Annotated[Framing | None, Field(description='Camera framing rules')] = None
    lighting: Annotated[
        str | None,
        Field(
            description="Lighting style (e.g., 'soft daylight', 'studio', 'golden hour', 'high-key', 'low-key')"
        ),
    ] = None
    preferred_aspect_ratios: Annotated[
        list[PreferredAspectRatio] | None,
        Field(
            description="Preferred aspect ratios for brand photography (e.g., '16:9', '4:5', '1:1')"
        ),
    ] = None
    realism: Annotated[Realism | None, Field(description='Level of photographic realism')] = None
    subject: Annotated[Subject | None, Field(description='Subject matter guidelines')] = None
    tags: Annotated[list[str] | None, Field(description='Additional style descriptors')] = None

Base model for AdCP types with spec-compliant serialization.

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 color_temperature : ColorTemperature | None
var contrast : Intensity | None
var depth_of_field : DepthOfField | None
var framing : Framing | None
var lighting : str | None
var model_config
var preferred_aspect_ratios : list[PreferredAspectRatio] | None
var realism : Realism | None
var subject : Subject | None
var tags : list[str] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class PreferredAspectRatio(RootModel[str]):
    root: Annotated[str, Field(pattern='^\\d+:\\d+$')]

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

Expand source code

class PreferredPosition(Enum):
    top_left = 'top-left'
    top_center = 'top-center'
    top_right = 'top-right'
    bottom_left = 'bottom-left'
    bottom_center = 'bottom-center'
    bottom_right = 'bottom-right'
    center = 'center'

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 bottom_center
var bottom_left
var bottom_right
var center
var top_center
var top_left
var top_right

class ProductCatalog (**data: Any)

Expand source code

class ProductCatalog(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    agentic_checkout: Annotated[
        AgenticCheckout | None, Field(description='Agentic checkout endpoint configuration')
    ] = None
    categories: Annotated[
        list[str] | None, Field(description='Product categories available in the catalog')
    ] = None
    feed_format: Annotated[FeedFormat | None, Field(description='Format of the product feed')] = (
        None
    )
    feed_url: Annotated[AnyUrl, Field(description='URL to product catalog feed')]
    last_updated: Annotated[
        AwareDatetime | None, Field(description='When the product catalog was last updated')
    ] = None
    update_frequency: Annotated[
        UpdateFrequency | None, Field(description='How frequently the product catalog is updated')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 last_updated : pydantic.types.AwareDatetime | None
var model_config
var update_frequency : UpdateFrequency | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ProductFocus (*args, **kwds)

Expand source code

class ProductFocus(Enum):
    in_use = 'in-use'
    isolated = 'isolated'
    lifestyle = 'lifestyle'
    detail = 'detail'

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 detail
var in_use
var isolated
var lifestyle

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[Type2, Field(description='Property type')]

Base model for AdCP types with spec-compliant serialization.

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 : Type2

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Realism (*args, **kwds)

Expand source code

class Realism(Enum):
    natural = 'natural'
    stylized = 'stylized'
    hyperreal = 'hyperreal'
    abstract = 'abstract'

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 abstract
var hyperreal
var natural
var stylized

class RightsAgent (**data: Any)

Expand source code

class RightsAgent(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    available_uses: Annotated[
        list[right_use.RightUse],
        Field(description='Rights uses available for licensing through this agent', min_length=1),
    ]
    countries: Annotated[
        list[Country] | None,
        Field(description='Countries where rights are available (ISO 3166-1 alpha-2)'),
    ] = None
    id: Annotated[str, Field(description='Agent identifier', pattern='^[a-z0-9_]+$')]
    right_types: Annotated[
        list[right_type.RightType] | None,
        Field(description='Types of rights available', min_length=1),
    ] = None
    url: Annotated[AnyUrl, Field(description='Rights agent MCP endpoint URL')]

Base model for AdCP types with spec-compliant serialization.

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 available_uses : list[RightUse]
var countries : list[Country] | None
var id : str
var model_config
var right_types : list[RightType] | None
var url : pydantic.networks.AnyUrl

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

Expand source code

class StrokeStyle(Enum):
    rounded = 'rounded'
    square = 'square'
    mixed = 'mixed'
    none = 'none'

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

attribute access::

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

value lookup:

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

name lookup:

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

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

>>> len(Color)
3

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

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

Ancestors

enum.Enum

Class variables

var mixed
var none
var rounded
var square

class Style (*args, **kwds)

Expand source code

class Style(Enum):
    none = 'none'
    subtle_grain = 'subtle_grain'
    noise = 'noise'
    paper = 'paper'
    fabric = 'fabric'
    concrete = 'concrete'

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 concrete
var fabric
var noise
var none
var paper
var subtle_grain

class Style1 (*args, **kwds)

Expand source code

class Style1(Enum):
    outline = 'outline'
    filled = 'filled'
    duotone = 'duotone'
    flat = 'flat'
    glyph = 'glyph'
    hand_drawn = 'hand_drawn'

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 duotone
var filled
var flat
var glyph
var hand_drawn
var outline

class StyleType (*args, **kwds)

Expand source code

class StyleType(Enum):
    flat_illustration = 'flat_illustration'
    geometric = 'geometric'
    gradient_mesh = 'gradient_mesh'
    editorial_collage = 'editorial_collage'
    hand_drawn = 'hand_drawn'
    minimal_line_art = 'minimal_line_art'
    field_3d_render = '3d_render'
    isometric = 'isometric'
    photographic_composite = 'photographic_composite'

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 editorial_collage
var field_3d_render
var flat_illustration
var geometric
var gradient_mesh
var hand_drawn
var isometric
var minimal_line_art
var photographic_composite

class Subject (**data: Any)

Expand source code

class Subject(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    people: Annotated[People | None, Field(description='People photography guidelines')] = None
    product_focus: Annotated[ProductFocus | None, Field(description='How products are shown')] = (
        None
    )
    setting: Annotated[
        str | None,
        Field(
            description="Environmental context for photography (e.g., 'indoor', 'outdoor', 'studio', 'urban', 'nature', 'workplace')"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 people : People | None
var product_focus : ProductFocus | None
var setting : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class Tagline(RootModel[list[LocalizedName]]):
    root: Annotated[
        list[LocalizedName],
        Field(description='Localized taglines with BCP 47 locale codes', 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[LocalizedName]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : list[LocalizedName]

class TextEntrance (*args, **kwds)

Expand source code

class TextEntrance(Enum):
    fade = 'fade'
    typewriter = 'typewriter'
    slide_up = 'slide_up'
    slide_left = 'slide_left'
    scale = 'scale'
    none = 'none'

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

attribute access::

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

value lookup:

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

name lookup:

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

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

>>> len(Color)
3

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

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

Ancestors

enum.Enum

Class variables

var fade
var none
var scale
var slide_left
var slide_up
var typewriter

class TextTransform (*args, **kwds)

Expand source code

class TextTransform(Enum):
    none = 'none'
    uppercase = 'uppercase'
    lowercase = 'lowercase'
    capitalize = 'capitalize'

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 capitalize
var lowercase
var none
var uppercase

class Texture (**data: Any)

Expand source code

class Texture(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    intensity: Annotated[Intensity | None, Field(description='Texture intensity')] = None
    style: Annotated[
        Style | None, Field(description='Texture style applied to creative assets')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 intensity : Intensity | None
var model_config
var style : Style | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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.

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.

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

Expand source code

class TransitionStyle(Enum):
    cut = 'cut'
    dissolve = 'dissolve'
    slide = 'slide'
    wipe = 'wipe'
    zoom = 'zoom'
    fade = 'fade'

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 cut
var dissolve
var fade
var slide
var wipe
var zoom

class Type (*args, **kwds)

Expand source code

class Type(Enum):
    icon_set = 'icon_set'
    illustration_system = 'illustration_system'
    image_library = 'image_library'
    video_library = 'video_library'
    template_library = 'template_library'

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 icon_set
var illustration_system
var image_library
var template_library
var video_library

class Type1 (*args, **kwds)

Expand source code

class Type1(Enum):
    border = 'border'
    divider = 'divider'
    frame = 'frame'
    watermark = 'watermark'
    pattern = 'pattern'
    texture_overlay = 'texture_overlay'
    decorative = 'decorative'

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 border
var decorative
var divider
var frame
var pattern
var texture_overlay
var watermark

class Type2 (*args, **kwds)

Expand source code

class Type2(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 TypeScale (**data: Any)

Expand source code

class TypeScale(AdCPBaseModel):
    base_width: Annotated[
        str | None,
        Field(
            description="Reference canvas width these sizes were designed for (e.g., '1080px'). Generative systems should scale proportionally for other canvas sizes."
        ),
    ] = None
    body: TypeScaleEntry | None = None
    caption: TypeScaleEntry | None = None
    cta: TypeScaleEntry | None = None
    heading: TypeScaleEntry | None = None
    subheading: TypeScaleEntry | None = None

Base model for AdCP types with spec-compliant serialization.

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 base_width : str | None
var body : TypeScaleEntry | None
var caption : TypeScaleEntry | None
var cta : TypeScaleEntry | None
var heading : TypeScaleEntry | None
var model_config
var subheading : TypeScaleEntry | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class TypeScaleEntry (**data: Any)

Expand source code

class TypeScaleEntry(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    font: Annotated[
        str | None,
        Field(
            description="Font family reference (e.g., 'primary', 'secondary', or a specific family name)"
        ),
    ] = None
    letter_spacing: Annotated[
        str | None, Field(description="Letter spacing (e.g., '-0.02em', '0.5px')")
    ] = None
    line_height: Annotated[str | None, Field(description="Line height (e.g., '1.2', '56px')")] = (
        None
    )
    size: Annotated[str | None, Field(description="Font size (e.g., '48px', '2rem')")] = None
    text_transform: Annotated[TextTransform | None, Field(description='Text transformation')] = None
    weight: Annotated[str | None, Field(description="Font weight (e.g., '700', 'bold')")] = None

Base model for AdCP types with spec-compliant serialization.

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 : str | None
var letter_spacing : str | None
var line_height : str | None
var model_config
var size : str | None
var text_transform : TextTransform | None
var weight : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class TypesAllowedEnum (*args, **kwds)

Expand source code

class TypesAllowedEnum(Enum):
    solid_color = 'solid_color'
    gradient = 'gradient'
    blurred_photo = 'blurred_photo'
    image = 'image'
    video = 'video'
    pattern = 'pattern'
    transparent = 'transparent'

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 blurred_photo
var gradient
var image
var pattern
var solid_color
var transparent
var video

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

Expand source code

class Usage(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    max_per_layout: Annotated[
        int | None, Field(description='Maximum distinct shapes per layout')
    ] = None
    overlap_allowed: Annotated[bool | None, Field(description='Whether shapes may overlap')] = None

Base model for AdCP types with spec-compliant serialization.

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 max_per_layout : int | None
var model_config
var overlap_allowed : bool | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Usage1 (**data: Any)

Expand source code

class Usage1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    max_per_frame: Annotated[int | None, Field(description='Maximum icons per creative frame')] = (
        None
    )
    size_ratio: Annotated[
        str | None, Field(description="Icon-to-layout size ratio (e.g., '1:8')")
    ] = None

Base model for AdCP types with spec-compliant serialization.

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 max_per_frame : int | None
var model_config
var size_ratio : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Variant (*args, **kwds)

Expand source code

class Variant(Enum):
    primary = 'primary'
    secondary = 'secondary'
    icon = 'icon'
    wordmark = 'wordmark'
    full_lockup = 'full-lockup'

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 full_lockup
var icon
var primary
var secondary
var wordmark

class VisualGuidelines (**data: Any)

Expand source code

class VisualGuidelines(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    asset_libraries: Annotated[
        list[AssetLibrary] | None,
        Field(
            description='References to managed asset libraries (icon sets, illustration systems, image collections). URLs are intended for human access; agent-facing DAM integration is under investigation.'
        ),
    ] = None
    colorways: Annotated[
        list[Colorway] | None,
        Field(description='Named color pairings for consistent foreground/background combinations'),
    ] = None
    composition: CompositionRules | None = None
    graphic_elements: Annotated[
        list[GraphicElement] | None,
        Field(
            description='Reusable decorative elements that are part of the brand visual identity (e.g., torn paper edges, watermarks, dividers)'
        ),
    ] = None
    graphic_style: GraphicStyle | None = None
    iconography: Iconography | None = None
    logo_placement: LogoPlacement | None = None
    motion: MotionGuidelines | None = None
    photography: PhotographyStyle | None = None
    restrictions: Annotated[
        list[str] | None,
        Field(
            description="Visual prohibitions and guardrails (e.g., 'Never use black backgrounds', 'Do not crop the logo', 'No stock photography of people on phones')"
        ),
    ] = None
    shapes: BrandShapes | None = None
    type_scale: Annotated[
        TypeScale | None,
        Field(
            description='Typography scale defining sizes and weights for different text roles. When sizes are in px, use base_width to indicate the reference canvas.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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_libraries : list[AssetLibrary] | None
var colorways : list[Colorway] | None
var composition : CompositionRules | None
var graphic_elements : list[GraphicElement] | None
var graphic_style : GraphicStyle | None
var iconography : Iconography | None
var logo_placement : LogoPlacement | None
var model_config
var motion : MotionGuidelines | None
var photography : PhotographyStyle | None
var restrictions : list[str] | None
var shapes : BrandShapes | None
var type_scale : TypeScale | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VoiceSynthesis (**data: Any)

Expand source code

class VoiceSynthesis(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.

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