Module adcp.types.generated_poc.brand_manifest

Classes

class Asset (**data: Any)

Expand source code

class Asset(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    asset_id: Annotated[str, Field(description='Unique identifier for this asset')]
    asset_type: Annotated[AssetType, Field(description='Type of asset')]
    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 asset name')] = None
    tags: Annotated[
        list[str] | None,
        Field(
            description="Tags for asset discovery (e.g., 'holiday', 'lifestyle', 'product_shot')"
        ),
    ] = 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.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var asset_id : str

var asset_type : AssetType

var 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

class AssetType (*args, **kwds)

Expand source code

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

Create a collection of name/value pairs.

Example enumeration:

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

Access them by:

• attribute access::

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

• value lookup:

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

• name lookup:

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

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

>>> len(Color)
3

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

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

Ancestors

• enum.Enum

Class variables

var audio

var image

var text

var video

class BrandManifest (**data: Any)

Expand source code

class BrandManifest(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    assets: Annotated[
        list[Asset] | None,
        Field(
            description='Brand asset library with explicit assets and tags. Assets are referenced inline with URLs pointing to CDN-hosted files.'
        ),
    ] = None
    colors: Annotated[Colors | None, Field(description='Brand color palette')] = None
    contact: Annotated[Contact | None, Field(description='Brand contact information')] = None
    disclaimers: Annotated[
        list[Disclaimer] | None,
        Field(description='Legal disclaimers or required text that must appear in creatives'),
    ] = None
    fonts: Annotated[Fonts | None, Field(description='Brand typography guidelines')] = None
    industry: Annotated[
        str | None,
        Field(
            description="Industry or vertical (e.g., 'retail', 'automotive', 'finance', 'healthcare')"
        ),
    ] = None
    logos: Annotated[
        list[Logo] | None,
        Field(description='Brand logo assets with semantic tags for different use cases'),
    ] = None
    metadata: Annotated[Metadata | None, Field(description='Additional brand metadata')] = None
    name: Annotated[str, Field(description='Brand or business name')]
    product_catalog: Annotated[
        ProductCatalog | None,
        Field(
            description='Product catalog information for e-commerce advertisers. Enables SKU-level creative generation and product selection.'
        ),
    ] = None
    tagline: Annotated[str | None, Field(description='Brand tagline or slogan')] = None
    target_audience: Annotated[
        str | None, Field(description='Primary target audience description')
    ] = None
    tone: Annotated[
        str | None,
        Field(
            description="Brand voice and messaging tone (e.g., 'professional', 'casual', 'humorous', 'trustworthy', 'innovative')"
        ),
    ] = None
    url: Annotated[
        AnyUrl | None,
        Field(
            description='Primary brand URL for context and asset discovery. Creative agents can infer brand information from this URL.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var assets : list[Asset] | None

var colors : Colors | None

var contact : Contact | None

var disclaimers : list[Disclaimer] | None

var fonts : Fonts | None

var industry : str | None

var logos : list[Logo] | None

var metadata : Metadata | None

var model_config

var name : str

var product_catalog : ProductCatalog | None

var tagline : str | None

var target_audience : str | None

var tone : str | None

var url : pydantic.networks.AnyUrl | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class Colors (**data: Any)

Expand source code

class Colors(AdCPBaseModel):
    accent: Annotated[
        str | None, Field(description='Accent color (hex format)', pattern='^#[0-9A-Fa-f]{6}$')
    ] = None
    background: Annotated[
        str | None, Field(description='Background color (hex format)', pattern='^#[0-9A-Fa-f]{6}$')
    ] = None
    primary: Annotated[
        str | None,
        Field(description='Primary brand color (hex format)', pattern='^#[0-9A-Fa-f]{6}$'),
    ] = None
    secondary: Annotated[
        str | None,
        Field(description='Secondary brand color (hex format)', pattern='^#[0-9A-Fa-f]{6}$'),
    ] = None
    text: Annotated[
        str | None, Field(description='Text color (hex format)', pattern='^#[0-9A-Fa-f]{6}$')
    ] = None

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var accent : str | None

var background : str | None

var model_config

var primary : str | None

var secondary : str | None

var text : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class Contact (**data: Any)

Expand source code

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

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var email : pydantic.networks.EmailStr | None

var model_config

var phone : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class Disclaimer (**data: Any)

Expand source code

class Disclaimer(AdCPBaseModel):
    context: Annotated[
        str | None,
        Field(
            description="When this disclaimer applies (e.g., 'financial_products', 'health_claims', 'all')"
        ),
    ] = None
    required: Annotated[bool | None, Field(description='Whether this disclaimer must appear')] = (
        True
    )
    text: Annotated[str, Field(description='Disclaimer text')]

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var context : str | None

var model_config

var required : bool | None

var text : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class FeedFormat (*args, **kwds)

Expand source code

class FeedFormat(Enum):
    google_merchant_center = 'google_merchant_center'
    facebook_catalog = 'facebook_catalog'
    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

class Fonts (**data: Any)

Expand source code

class Fonts(AdCPBaseModel):
    font_urls: Annotated[
        list[AnyUrl] | None, Field(description='URLs to web font files if using custom fonts')
    ] = None
    primary: Annotated[str | None, Field(description='Primary font family name')] = None
    secondary: Annotated[str | None, Field(description='Secondary font family name')] = None

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var font_urls : list[pydantic.networks.AnyUrl] | None

var model_config

var primary : str | None

var secondary : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class Logo (**data: Any)

Expand source code

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

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var height : int | None

var model_config

var tags : list[str] | None

var url : pydantic.networks.AnyUrl

var width : int | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class Metadata (**data: Any)

Expand source code

class Metadata(AdCPBaseModel):
    created_date: Annotated[
        AwareDatetime | None, Field(description='When this brand manifest was created')
    ] = None
    updated_date: Annotated[
        AwareDatetime | None, Field(description='When this brand manifest was last updated')
    ] = None
    version: Annotated[str | None, Field(description='Brand card version number')] = None

Base model for AdCP types with spec-compliant serialization.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var created_date : pydantic.types.AwareDatetime | None

var model_config

var updated_date : pydantic.types.AwareDatetime | None

var version : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json

class ProductCatalog (**data: Any)

Expand source code

class ProductCatalog(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    categories: Annotated[
        list[str] | None,
        Field(description='Product categories available in the catalog (for filtering)'),
    ] = None
    feed_format: Annotated[FeedFormat | None, Field(description='Format of the product feed')] = (
        FeedFormat.google_merchant_center
    )
    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.

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

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var 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

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