Module `adcp.types.domains.brand_discovery`

Classes

class AgenticCheckout (**data: Any)

Expand source code

class AgenticCheckout(AdCPBaseModel):
    endpoint: Annotated[AnyUrl, Field(description='Base URL for checkout session API')]
    spec: Annotated[
        str,
        Field(
            description='Checkout API specification identifier. Use a namespaced string to identify the checkout protocol (e.g., vendor-prefixed or custom). Vendor-specific values belong under ext.{vendor}.'
        ),
    ]
    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 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.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class Agents(RootModel[list[BrandAgentEntry]]):
    root: Annotated[
        list[BrandAgentEntry],
        Field(
            description='Agents declared by this brand or house. Multiple entries with the same type are permitted when they have distinct url values, such as one endpoint URL per tenant or property scope. Agent url values MUST be unique within this array; duplicate urls are invalid because signature verifiers resolve a signing key by matching one agent url to one agents[] entry and reject ambiguous matches.'
        ),
    ]

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

Class variables

var model_config
var root : list[BrandAgentEntry]

class AiTool (**data: Any)

Expand source code

class AiTool(AdCPBaseModel):
    name: Annotated[
        str,
        Field(
            description="Name of the AI tool or model (e.g., 'DALL-E 3', 'Stable Diffusion XL', 'Gemini')"
        ),
    ]
    version: Annotated[
        str | None,
        Field(
            description="Version identifier for the AI tool or model (e.g., '25.1', '0125', '2.1'). For generative models, use the model version rather than the API version."
        ),
    ] = None
    provider: Annotated[
        str | None,
        Field(
            description="Organization that provides the AI tool (e.g., 'OpenAI', 'Stability AI', 'Google')"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 name : str
var provider : str | None
var version : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class AnimationSpeed (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var fast
var moderate
var slow

class Architecture (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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[AssetContentType, Field(description='Type of asset content')]
    url: Annotated[AnyUrl, Field(description='URL to CDN-hosted asset file')]
    tags: Annotated[
        list[str] | None,
        Field(description="Tags for discovery (e.g., 'hero', 'lifestyle', 'product', 'holiday')"),
    ] = None
    name: Annotated[
        LocalizedScalar | None,
        Field(description='Human-readable name, either a legacy plain string or localized values.'),
    ] = None
    description: Annotated[
        LocalizedScalar | None,
        Field(
            description='Asset description or usage notes, either a legacy plain string or localized values.'
        ),
    ] = None
    width: Annotated[SchemaInt | None, Field(description='Image/video width in pixels')] = None
    height: Annotated[SchemaInt | None, Field(description='Image/video height in pixels')] = None
    duration_seconds: Annotated[
        StrictFloat | None, Field(description='Video/audio duration in seconds')
    ] = None
    file_size_bytes: Annotated[SchemaInt | None, Field(description='File size in bytes')] = None
    format: Annotated[str | None, Field(description="File format (e.g., 'jpg', 'mp4', 'mp3')")] = (
        None
    )
    metadata: Annotated[
        dict[str, Any] | None, Field(description='Additional asset-specific metadata')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : LocalizedScalar | 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 : LocalizedScalar | 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 AssetContentType (*args, **kwds)

Expand source code

class AssetContentType(StrEnum):
    image = 'image'
    video = 'video'
    audio = 'audio'
    text = 'text'
    markdown = 'markdown'
    html = 'html'
    css = 'css'
    javascript = 'javascript'
    zip = 'zip'
    vast = 'vast'
    daast = 'daast'
    url = 'url'
    webhook = 'webhook'
    brief = 'brief'
    catalog = 'catalog'
    published_post = 'published_post'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var audio
var brief
var catalog
var css
var daast
var html
var image
var javascript
var markdown
var published_post
var text
var url
var vast
var video
var webhook
var zip

class AssetLibrary (**data: Any)

Expand source code

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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : Type2 | 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',
    )
    domain: Annotated[
        Domain, Field(description="Domain of the authorized operator (e.g., 'groupm.com')")
    ]
    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[Country1] | None,
        Field(
            description='ISO 3166-1 alpha-2 country codes where this authorization applies. Omit for global authorization.'
        ),
    ] = None
    scopes: Annotated[
        list[Scope1] | None,
        Field(
            description="Activities this operator is authorized to perform for the listed brands and countries. Omit for backwards-compatible broad authorization. Use ['all'] only when every listed scope is delegated.",
            min_length=1,
        ),
    ] = None
    valid_from: Annotated[
        AwareDatetime | None,
        Field(
            description='ISO 8601 timestamp when this operator authorization starts. Omit when authorization is already active or the start date is not tracked.'
        ),
    ] = None
    valid_until: Annotated[
        AwareDatetime | None,
        Field(
            description='ISO 8601 timestamp when this operator authorization expires. Consumers MUST treat entries at or after this timestamp as inactive for authorization decisions.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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[Country1] | None
var domain : Domain
var model_config
var scopes : list[Scope1] | None
var valid_from : pydantic.types.AwareDatetime | None
var valid_until : pydantic.types.AwareDatetime | None

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',
    )
    provider: str | None = None
    avatar_id: str | None = None
    settings: dict[str, Any] | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    dark_bg = 'dark-bg'
    light_bg = 'light-bg'
    transparent_bg = 'transparent-bg'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var dark_bg
var light_bg
var transparent_bg

class BackgroundContrast (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class BorderRadius(AdCPBaseModel):
    __pydantic_extra__: Dict[str, str]
    model_config = ConfigDict(
        extra='allow',
    )
    none: Annotated[str | None, Field(description="Explicitly sharp corners (e.g., '0')")] = None
    default: Annotated[
        str | None,
        Field(
            description="Default border radius for UI components (e.g., '8px', '12px', '0'). For graphic/illustration elements, see graphic_style.corner_radius."
        ),
    ] = None
    small: Annotated[
        str | None, Field(description="Small border radius for compact elements (e.g., '4px')")
    ] = None
    large: Annotated[
        str | None,
        Field(description="Large border radius for cards and containers (e.g., '16px', '24px')"),
    ] = None
    pill: Annotated[str | None, Field(description="Fully rounded / pill shape (e.g., '999px')")] = (
        None
    )

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 default : str | None
var large : str | None
var model_config
var none : str | None
var pill : str | None
var small : str | 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',
    )
    id: Annotated[
        BrandId, Field(description='Brand identifier within the house. House chooses this ID.')
    ]
    url: Annotated[
        AnyUrl | None, Field(description='Primary brand URL for context and asset discovery')
    ] = None
    identity_relying_parties: Annotated[
        list[IdentityRelyingParty] | None,
        Field(
            description='Verified-identity relying parties scoped to this brand/property, for attestation provenance in TMP Identity Match. Use when a brand or property runs its own relying_party_id (per-property pseudonyms); entity-wide relying parties live on the house object. See specs/tmp-verified-identity-attestation.md.'
        ),
    ] = None
    names: Annotated[
        list[LocalizedName],
        Field(
            description='Localized brand names. Multiple entries per language allowed for aliases.',
            min_length=1,
        ),
    ]
    keller_type: KellerType | None = None
    parent_brand: Annotated[
        BrandId | None, Field(description='Parent brand ID for sub-brands and endorsed brands')
    ] = None
    description: Annotated[str | None, Field(description='Brand description')] = None
    industries: Annotated[
        list[str] | None,
        Field(
            description="Brand industries (e.g., ['automotive'] or ['pharmaceutical', 'cpg'] for a consumer health company). Describes what the company does — not what regulatory regimes apply (use policy_categories for that).",
            min_length=1,
        ),
    ] = None
    target_audience: Annotated[str | None, Field(description='Primary target audience')] = None
    logos: Annotated[list[Logo] | None, Field(description='Brand logo assets')] = None
    colors: Colors | None = None
    fonts: Fonts | None = None
    tone: Annotated[
        str | Tone | None, Field(description='Brand voice and messaging tone guidelines')
    ] = 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
    assets: Annotated[list[Asset] | None, Field(description='Brand asset library')] = None
    properties: Annotated[
        list[Property] | None,
        Field(
            description='Digital properties associated with this brand — owned, managed, or represented'
        ),
    ] = None
    product_catalog: ProductCatalog | None = None
    privacy_policy_url: Annotated[
        AnyUrl | None, Field(description="URL to the brand's privacy policy")
    ] = None
    data_subject_contestation: DataSubjectContestation | None = None
    disclaimers: Annotated[
        list[Disclaimer] | None, Field(description='Legal disclaimers for creatives')
    ] = None
    trademarks: Annotated[
        list[Trademark] | None,
        Field(
            description="Brand-level registered trademarks. Use for marks the brand owns or controls (e.g., a sub-brand's own marks distinct from the corporate parent). House-level trademarks live on the house object; resolution between the two is union — both lists are valid claims."
        ),
    ] = None
    voice_synthesis: Annotated[
        VoiceSynthesis | None,
        Field(description='TTS voice synthesis configuration for AI-generated audio'),
    ] = None
    avatar: Annotated[Avatar | None, Field(description='Visual avatar configuration')] = None
    visual_guidelines: Annotated[
        VisualGuidelines | None,
        Field(description='Structured visual rules for generative creative systems'),
    ] = None
    agents: Annotated[
        Agents | None,
        Field(
            description='Agents authorized to act on behalf of this brand. Consumers resolving an agent by URL use the matching brand-level entry; do not infer a type-wide override of unrelated house-level entries when multiple same-type entries exist.'
        ),
    ] = None
    brand_agent: Annotated[
        BrandAgent | None,
        Field(
            deprecated=True,
            description="Deprecated: use agents array with type 'brand' instead. Brand agent that provides dynamic brand data via MCP.",
        ),
    ] = None
    rights_agent: Annotated[
        RightsAgent | None,
        Field(
            deprecated=True,
            description="Deprecated: use agents array with type 'rights' instead. Rights licensing agent for this brand.",
        ),
    ] = None
    contact: Annotated[Contact1 | None, Field(description='Brand-level contact information')] = 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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

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

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

Ancestors

AdCPBaseModel
pydantic.main.BaseModel

Subclasses

BrandDiscovery5

Class variables

var agents : Agents | None
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 data_subject_contestation : DataSubjectContestation | None
var description : str | None
var disclaimers : list[Disclaimer] | None
var fonts : Fonts | None
var id : BrandId
var identity_relying_parties : list[IdentityRelyingParty] | None
var industries : list[str] | None
var keller_type : KellerType | None
var logos : list[Logo] | None
var model_config
var names : list[LocalizedName]
var parent_brand : BrandId | None
var privacy_policy_url : pydantic.networks.AnyUrl | None
var product_catalog : ProductCatalog | None
var properties : list[Property] | None
var rights_agent : RightsAgent | None
var tagline : str | Tagline | None
var target_audience : str | None
var tone : str | Tone | None
var trademarks : list[Trademark] | 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 (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Brand1(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^([a-z0-9_]+|\\*)$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class BrandAgent (**data: Any)

Expand source code

class BrandAgent(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[
        AnyUrl,
        Field(
            description="Brand agent MCP endpoint URL. Callers comparing this URL against another value (e.g., resolving 'is this the brand's declared agent?' against a discovery cache) MUST canonicalize both sides per the AdCP URL canonicalization rules, not byte-equality. See docs/reference/url-canonicalization."
        ),
    ]
    id: Annotated[
        str,
        Field(
            description='Agent identifier (useful for logging, multi-tenant DAMs)',
            pattern='^[a-z0-9_]+$',
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class BrandAgentEntry(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    type: Annotated[BrandAgentType, Field(description='Functional role of this agent')]
    url: Annotated[
        AnyUrl,
        Field(
            description="Agent endpoint URL (MCP or A2A). Callers comparing a brand's declared agent URL against another value (e.g., resolving 'is this the agent that signed this artifact?' or matching against a discovery cache) MUST canonicalize both sides per the AdCP URL canonicalization rules, not byte-equality. After the publication chain and an authorized request-signing key verify, this exact entry's canonical URL is the stable Agent identity input for principal mapping; the domain, JWKS URI, kid, and key material are credential or trust facts beneath it, not the Agent identity. See docs/reference/url-canonicalization."
        ),
    ]
    id: Annotated[
        str,
        Field(
            description='Agent identifier (useful for logging, multi-tenant platforms)',
            max_length=100,
            pattern='^[a-z0-9_]+$',
        ),
    ]
    description: Annotated[
        str | None,
        Field(
            description="Human-readable description of this agent's capabilities or scope",
            max_length=500,
        ),
    ] = None
    jwks_uri: Annotated[
        AnyUrl | None,
        Field(
            description="HTTPS URL of the agent's JWKS (RFC 7517) containing public keys used to verify artifacts this agent signs or requests it sends. Verified artifacts include signed governance_context tokens (for governance agents) and RFC 9421 HTTP Signatures on outgoing requests (for any agent). When absent, verifiers MUST default to /.well-known/jwks.json on the origin of `url`. Keys are identified by `kid` in the JWS header or RFC 9421 `keyid` parameter; JWKS MAY contain multiple keys to support rotation and per-purpose separation via `key_ops` and `use`."
        ),
    ] = None
    available_uses: Annotated[
        list[RightUse] | None,
        Field(description='For rights agents: rights uses available for licensing', min_length=1),
    ] = None
    right_types: Annotated[
        list[RightType] | None,
        Field(description='For rights agents: types of rights available', min_length=1),
    ] = None
    countries: Annotated[
        list[Country1] | None,
        Field(
            description='ISO 3166-1 alpha-2 country codes where this agent operates. Omit for global scope.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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] | None
var countries : list[Country1] | None
var description : str | None
var id : str
var jwks_uri : pydantic.networks.AnyUrl | None
var model_config
var right_types : list[RightType] | None
var type : BrandAgentType
var url : pydantic.networks.AnyUrl

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class BrandAgentType (*args, **kwds)

Expand source code

class BrandAgentType(StrEnum):
    brand = 'brand'
    rights = 'rights'
    measurement = 'measurement'
    governance = 'governance'
    creative = 'creative'
    sales = 'sales'
    buying = 'buying'
    signals = 'signals'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var brand
var buying
var creative
var governance
var measurement
var rights
var sales
var signals

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')
    ]
    redirect_reason: Annotated[
        RedirectReason | None,
        Field(
            description="Optional structured signal indicating why this redirect was put in place. Consumers SHOULD use this to inform cache TTL decisions: 'acquisition' / 'divestiture' / 'rebrand' / 'consolidation' suggest the resolved target is in transition and consumers SHOULD shorten cache TTL until stable. 'regional' / 'legacy' suggest a stable redirect with no special cache handling needed. Free-text rationale belongs in 'note'."
        ),
    ] = None
    redirect_effective_at: Annotated[
        AwareDatetime | None,
        Field(
            description='Optional timestamp when this redirect became effective. Caches MUST treat any entry cached before this timestamp as stale and re-fetch through the redirect.'
        ),
    ] = None
    note: Annotated[
        str | None, Field(description='Optional human-readable rationale for the redirect.')
    ] = None
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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
var note : str | None
var redirect_effective_at : pydantic.types.AwareDatetime | None
var redirect_reason : RedirectReason | None

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')]
    region: Annotated[
        str | None,
        Field(
            description='ISO 3166-1 alpha-2 country code if this is a regional domain',
            pattern='^[A-Z]{2}$',
        ),
    ] = None
    redirect_reason: Annotated[
        RedirectReason | None,
        Field(
            description="Optional structured signal indicating why this redirect was put in place. Consumers SHOULD use this to inform cache TTL decisions: 'acquisition' / 'divestiture' / 'rebrand' / 'consolidation' suggest the resolved target is in transition and consumers SHOULD shorten cache TTL until stable. 'regional' / 'legacy' suggest a stable redirect with no special cache handling needed. Free-text rationale belongs in 'note'."
        ),
    ] = None
    redirect_effective_at: Annotated[
        AwareDatetime | None,
        Field(
            description='Optional timestamp when this redirect became effective. Caches MUST treat any entry cached before this timestamp as stale and re-fetch through the redirect.'
        ),
    ] = None
    note: Annotated[
        str | None, Field(description='Optional human-readable rationale for the redirect.')
    ] = None
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 redirect_effective_at : pydantic.types.AwareDatetime | None
var redirect_reason : RedirectReason | 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
    version: str | None = None
    agents: Agents | None = None
    brand_agent: Annotated[BrandAgent | None, Field(deprecated=True)] = None
    contact: Contact | None = None
    data_subject_contestation: DataSubjectContestation | None = None
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 agents : Agents | None
var brand_agent : BrandAgent | None
var contact : Contact | None
var data_subject_contestation : DataSubjectContestation | 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
    version: str | None = None
    default_language: DefaultLanguage | None = None
    house: House
    brands: Annotated[
        list[Brand] | None,
        Field(
            description='Inline brands owned by this house (parent-owned data). Use for sub-brands without their own canonical document — typically those without a dedicated domain or that the holdco wants to manage centrally. A brand_id MUST NOT appear in both brands[] and brand_refs[].',
            min_length=1,
        ),
    ] = None
    brand_refs: Annotated[
        list[PortfolioEntry] | None,
        Field(
            description="Portfolio entries for brands owned by this house that publish their own canonical brand.json elsewhere (child-owned data). Each entry asserts ownership plus where the child's document lives. Mutual-assertion trust: the pointed-to document's house_domain must equal this house's domain. Invariants: a brand_id MUST NOT appear in both brands[] and brand_refs[]; brand_id and domain MUST each be unique within brand_refs[]. See docs/brand-protocol/brand-json.mdx",
            min_length=1,
        ),
    ] = None
    contact: Contact | None = 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
    trademarks: Annotated[
        list[Trademark] | None,
        Field(
            description='House-level (corporate) registered trademarks. Brand-level marks live on individual brand entries; resolution is union.'
        ),
    ] = None
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 brand_refs : list[PortfolioEntry] | None
var brands : list[Brand] | None
var contact : Contact | None
var default_language : DefaultLanguage | 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 BrandDiscovery5 (**data: Any)

Expand source code

class BrandDiscovery5(Brand):
    field_schema: Annotated[str | None, Field(alias='$schema')] = None
    version: str | None = None
    default_language: DefaultLanguage | None = None
    house_domain: Annotated[
        Domain | None,
        Field(
            description="Optional pointer to the corporate house this brand belongs to. The named house's brand_refs[] MUST reciprocate for mutual-assertion trust. Single-hop only — a brand cannot itself declare brand_refs[]. Omit for standalone brands (no house)."
        ),
    ] = None
    last_updated: AwareDatetime | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Brand
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var default_language : DefaultLanguage | None
var field_schema : str | None
var house_domain : Domain | None
var last_updated : pydantic.types.AwareDatetime | None
var model_config
var version : str | None

Inherited members

Brand:
- model_dump
- model_dump_json
- model_summary

class BrandId (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class BrandId(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z0-9_]+$'}
    _json_schema_extra = {
        'description': 'Brand identifier within the house portfolio. Lowercase alphanumeric with underscores. House chooses this ID.',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class BrandIdModel (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class BrandIdModel(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z0-9_]+$'}
    _json_schema_extra = {
        'description': 'Identifier for a brand within a house portfolio. Must be lowercase alphanumeric with underscores only. The house chooses this identifier.',
        'examples': ['tide', 'cheerios', 'air_jordan', 'nike', 'pampers'],
        'title': 'Brand ID',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class BrandKitOverride (**data: Any)

Expand source code

class BrandKitOverride(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    logo: Annotated[ImageAsset | None, Field(description='Override logo asset.')] = None
    colors: Annotated[Colors1 | None, Field(description='Override brand colors (hex strings).')] = (
        None
    )
    voice: Annotated[
        str | None,
        Field(
            description='Override brand-voice description for surface-composed text/audio output.'
        ),
    ] = None
    tagline: Annotated[str | None, Field(description='Override tagline.')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : Colors1 | None
var logo : ImageAsset | None
var model_config
var tagline : str | None
var voice : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class BrandRef (**data: Any)

Expand source code

class BrandRef(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    domain: Annotated[
        str,
        Field(
            description="Domain where /.well-known/brand.json is hosted, or the brand's operating domain",
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ]
    brand_id: Annotated[
        BrandIdModel | None,
        Field(
            description='Brand identifier within the house portfolio. Optional for single-brand domains.'
        ),
    ] = None
    countries: Annotated[
        list[Country1] | None,
        Field(
            description='Canonical set of ISO 3166-1 alpha-2 countries for this advertiser identity. Omit for a global/default identity. Array order is not meaningful; producers MUST sort codes lexicographically before computing keys or signatures. This qualifies account identity and is not delivery targeting.',
            min_length=1,
        ),
    ] = None
    industries: Annotated[
        list[str] | None,
        Field(
            description="Inline override for the brand's industries. Useful when the caller cannot modify the brand's canonical brand.json but needs to declare industries for governance (e.g., Annex III vertical detection). brand.json remains the canonical source; when omitted here, governance agents SHOULD resolve from brand.json."
        ),
    ] = None
    data_subject_contestation: Annotated[
        DataSubjectContestation1 | None,
        Field(
            description="Inline override for the brand's contestation contact point. Useful when the operator does not control brand.json but needs to discharge Art 22(3) for this plan. brand.json is canonical; when omitted, governance agents resolve brand → house → missing."
        ),
    ] = None
    brand_kit_override: Annotated[
        BrandKitOverride | None,
        Field(
            description="Inline override for brand-kit fields normally resolved from `/.well-known/brand.json` on `domain` (logo, colors, voice, tagline). Use when brand.json is missing, stale, or inappropriate for this specific call — e.g., a campaign-scoped tagline, a co-branded creative, a freshly-rebranded color palette the brand.json hasn't shipped yet. Same inline-override pattern as `industries` and `data_subject_contestation` above: brand.json is canonical, the override is per-call. Adopters needing to override fields outside this subset (`voice_attributes`, `prohibited_terms`, etc.) MUST publish a different brand.json and reference it via a different `domain` — the inline override is intentionally narrow to a small high-traffic subset.\n\n**Merge semantics (normative).** The merge is **field-level**, not whole-object replacement. Each field within `brand_kit_override` (`logo`, `colors`, `voice`, `tagline`) is evaluated independently — when a field is present on the override the override value applies; when a field is absent the brand.json value applies (or is absent if brand.json doesn't carry one either). For composite fields (`colors.primary`, `colors.secondary`, `colors.accent`), the merge is one level deeper: each color slot is evaluated independently — a producer can override `colors.primary` while still inheriting `colors.secondary` from brand.json. SDKs MUST NOT treat a present `brand_kit_override.colors` as wiping the brand.json `colors` block entirely; only the per-slot fields present in the override take precedence. Without this rule, a partial-override semantics would diverge across SDKs and produce inconsistent rendering for the same payload."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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_id : BrandIdModel | None
var brand_kit_override : BrandKitOverride | None
var countries : list[Country1] | None
var data_subject_contestation : DataSubjectContestation1 | None
var domain : str
var industries : list[str] | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class C2pa(AdCPBaseModel):
    manifest_url: Annotated[
        AnyUrl, Field(description='URL to the C2PA manifest store for this content')
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 manifest_url : pydantic.networks.AnyUrl
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class C2paWatermarkAction (*args, **kwds)

Expand source code

class C2paWatermarkAction(StrEnum):
    c2pa_watermarked_bound = 'c2pa.watermarked.bound'
    c2pa_watermarked_unbound = 'c2pa.watermarked.unbound'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var c2pa_watermarked_bound
var c2pa_watermarked_unbound

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

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class ColorConstraint(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    color: Annotated[ColorRef, Field(description='Color role or value this constraint governs.')]
    applies_to: Annotated[
        list[Surface] | None, Field(description='Surfaces where this color may be used.')
    ] = None
    allowed_on: Annotated[
        list[ColorRef] | None,
        Field(description='Backgrounds, surfaces, or color roles where this color is allowed.'),
    ] = None
    forbidden_on: Annotated[
        list[ColorRef] | None,
        Field(description='Backgrounds, surfaces, or color roles where this color is forbidden.'),
    ] = None
    never_pair_with: Annotated[
        list[ColorRef] | None,
        Field(description='Color roles or values that must not be paired with this color.'),
    ] = None
    contexts: Annotated[
        list[str] | None,
        Field(
            description='Channels or creative contexts where this constraint applies, such as digital, print, social, or ctv_end_card.'
        ),
    ] = None
    severity: GuidelineSeverity | None = None
    description: Annotated[
        str | None,
        Field(description='Human-readable rationale or source-language summary for the rule.'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 allowed_on : list[ColorRef] | None
var applies_to : list[Surface] | None
var color : ColorRef
var contexts : list[str] | None
var description : str | None
var forbidden_on : list[ColorRef] | None
var model_config
var never_pair_with : list[ColorRef] | None
var severity : GuidelineSeverity | 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',
    )
    roles: Annotated[
        list[str] | None,
        Field(
            description='Named color roles used in the library (e.g., base, shadow_1, highlight_1, stroke)'
        ),
    ] = None
    palettes: Annotated[
        list[Palette] | None,
        Field(description='Named color palettes mapping roles to specific colors'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 ColorRef (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class ColorRef(RootModel[ColorRef1 | ColorRef2 | ColorRef3]):
    root: Annotated[
        ColorRef1 | ColorRef2 | ColorRef3,
        Field(
            description='Reference to a brand color or usage surface for machine-readable guideline constraints. Use kind=name for palette lookup keys in colors, kind=value for a literal hex color, and kind=surface for layout surfaces such as background or text.'
        ),
    ]
    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[ColorRef1, ColorRef2, ColorRef3]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : ColorRef1 | ColorRef2 | ColorRef3

class ColorRef1 (**data: Any)

Expand source code

class ColorRef1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    kind: Annotated[
        Literal['name'], Field(description='Discriminator for the color reference variant.')
    ] = 'name'
    name: Annotated[
        str,
        Field(
            description='Key from the colors object, such as market_yellow, river_green, or any custom palette key. Unambiguous lookup into colors{}.'
        ),
    ]
    value: Annotated[
        HexColor | None, Field(description='Literal hex color when no palette key exists.')
    ] = None
    surface: Annotated[
        Surface | None, Field(description='Usage surface rather than a specific color value.')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 kind : Literal['name']
var model_config
var name : str
var surface : Surface | None
var value : HexColor | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ColorRef2 (**data: Any)

Expand source code

class ColorRef2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    kind: Annotated[
        Literal['value'], Field(description='Discriminator for the color reference variant.')
    ] = 'value'
    name: Annotated[
        str | None,
        Field(
            description='Key from the colors object, such as market_yellow, river_green, or any custom palette key. Unambiguous lookup into colors{}.'
        ),
    ] = None
    value: Annotated[HexColor, Field(description='Literal hex color when no palette key exists.')]
    surface: Annotated[
        Surface | None, Field(description='Usage surface rather than a specific color value.')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 kind : Literal['value']
var model_config
var name : str | None
var surface : Surface | None
var value : HexColor

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ColorRef3 (**data: Any)

Expand source code

class ColorRef3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    kind: Annotated[
        Literal['surface'], Field(description='Discriminator for the color reference variant.')
    ] = 'surface'
    name: Annotated[
        str | None,
        Field(
            description='Key from the colors object, such as market_yellow, river_green, or any custom palette key. Unambiguous lookup into colors{}.'
        ),
    ] = None
    value: Annotated[
        HexColor | None, Field(description='Literal hex color when no palette key exists.')
    ] = None
    surface: Annotated[
        Surface, Field(description='Usage surface rather than a specific color value.')
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 kind : Literal['surface']
var model_config
var name : str | None
var surface : Surface
var value : HexColor | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ColorTemperature (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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 (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ColorValue1(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^#[0-9A-Fa-f]{6}$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

Subclasses

ColorValue2Item

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 (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class ColorValue2Item(ColorValue1):
    pass

A str generated from a JSON Schema string root.

Ancestors

ColorValue1
adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Colors (**data: Any)

Expand source code

class Colors(AdCPBaseModel):
    __pydantic_extra__: Dict[str, ColorValue]
    model_config = ConfigDict(
        extra='allow',
    )
    primary: ColorValue | None = None
    secondary: ColorValue | None = None
    accent: ColorValue | None = None
    background: ColorValue | None = None
    text: ColorValue | None = None
    heading: ColorValue | None = None
    body: ColorValue | None = None
    label: ColorValue | None = None
    border: ColorValue | None = None
    divider: ColorValue | None = None
    surface_1: ColorValue | None = None
    surface_2: ColorValue | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 body : ColorValue | None
var border : ColorValue | None
var divider : ColorValue | None
var heading : ColorValue | None
var label : ColorValue | None
var model_config
var primary : ColorValue | None
var secondary : ColorValue | None
var surface_1 : ColorValue | None
var surface_2 : ColorValue | None
var text : ColorValue | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Colors1 (**data: Any)

Expand source code

class Colors1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    primary: Annotated[str | None, Field(pattern='^#[0-9a-fA-F]{6}$')] = None
    secondary: Annotated[str | None, Field(pattern='^#[0-9a-fA-F]{6}$')] = None
    accent: Annotated[str | None, Field(pattern='^#[0-9a-fA-F]{6}$')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 model_config
var primary : str | None
var secondary : str | 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',
    )
    name: Annotated[str, Field(description="Colorway name (e.g., 'primary', 'inverted', 'subtle')")]
    foreground: HexColor
    background: HexColor
    accent: HexColor | None = None
    border: HexColor | None = None
    cta_foreground: Annotated[
        HexColor | None, Field(description='CTA text/icon color, if different from foreground')
    ] = None
    cta_background: Annotated[
        HexColor | None, Field(description='CTA button/container color, if different from accent')
    ] = 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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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',
    )
    overlays: Annotated[Overlays | None, Field(description='Graphic overlay rules')] = None
    texture: Annotated[Texture | None, Field(description='Texture treatment rules')] = None
    backgrounds: Annotated[Backgrounds | None, Field(description='Background treatment rules')] = (
        None
    )

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class Contrast(StrEnum):
    low = 'low'
    medium = 'medium'
    high = 'high'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var high
var low
var medium

class CornerStyle (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var mixed
var rounded
var square

class Country (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Country(ScalarStr):
    __slots__ = ()
    _constraints = {'max_length': 2, 'min_length': 2}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Country1 (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Country1(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[A-Z]{2}$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class DataSubjectContestation (**data: Any)

Expand source code

class DataSubjectContestation(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    url: Annotated[
        AnyUrl | None,
        Field(description='HTTPS URL to a human-accessible contestation form or information page.'),
    ] = None
    email: Annotated[
        EmailStr | None,
        Field(
            description='Email address for contestation requests. Deployer MUST monitor and respond within the timelines set by applicable law (e.g., 1 month under GDPR Art. 12(3)).'
        ),
    ] = None
    languages: Annotated[
        list[str] | None,
        Field(
            description="BCP 47 language tags the contestation channel supports (e.g., ['en', 'de', 'fr']). At minimum SHOULD include a language spoken in every jurisdiction where the brand runs regulated-vertical campaigns."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 languages : list[str] | None
var model_config
var url : pydantic.networks.AnyUrl | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DataSubjectContestation1 (**data: Any)

Expand source code

class DataSubjectContestation1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    url: AnyUrl | None = None
    email: EmailStr | None = None
    languages: list[str] | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 languages : list[str] | None
var model_config
var url : pydantic.networks.AnyUrl | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DeclaredBy (**data: Any)

Expand source code

class DeclaredBy(AdCPBaseModel):
    agent_url: Annotated[
        AnyUrl | None,
        Field(description='URL of the agent or service that declared this provenance'),
    ] = None
    role: Annotated[Role, Field(description='Role of the declaring party in the supply chain')]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 agent_url : pydantic.networks.AnyUrl | None
var model_config
var role : Role

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DefaultLanguage (**data: Any)

Expand source code

class DefaultLanguage(AdCPBaseModel):
    pass

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DepthOfField (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var deep
var medium
var shallow

class DigitalSourceType (*args, **kwds)

Expand source code

class DigitalSourceType(StrEnum):
    digital_capture = 'digital_capture'
    digital_creation = 'digital_creation'
    trained_algorithmic_media = 'trained_algorithmic_media'
    composite_with_trained_algorithmic_media = 'composite_with_trained_algorithmic_media'
    algorithmic_media = 'algorithmic_media'
    composite_capture = 'composite_capture'
    composite_synthetic = 'composite_synthetic'
    human_edits = 'human_edits'
    data_driven_media = 'data_driven_media'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var algorithmic_media
var composite_capture
var composite_synthetic
var composite_with_trained_algorithmic_media
var data_driven_media
var digital_capture
var digital_creation
var human_edits
var trained_algorithmic_media

class Disclaimer (**data: Any)

Expand source code

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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class Disclosure(AdCPBaseModel):
    required: Annotated[
        StrictBool,
        Field(
            description="The declaring party's claim that AI disclosure is required for this content under applicable regulations. This is a declared signal carried through the supply chain — useful as a routing and audit input — not a regulatory determination made by the protocol. Receiving parties remain responsible for their own jurisdictional analysis and should not treat `required: false` as compliance cover."
        ),
    ]
    jurisdictions: Annotated[
        list[Jurisdiction] | None,
        Field(description='Jurisdictions where disclosure obligations apply', min_length=1),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 jurisdictions : list[Jurisdiction] | None
var model_config
var required : bool

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class DisclosurePersistence (*args, **kwds)

Expand source code

class DisclosurePersistence(StrEnum):
    continuous = 'continuous'
    initial = 'initial'
    flexible = 'flexible'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var continuous
var flexible
var initial

class DisclosurePosition (*args, **kwds)

Expand source code

class DisclosurePosition(StrEnum):
    prominent = 'prominent'
    footer = 'footer'
    audio = 'audio'
    subtitle = 'subtitle'
    overlay = 'overlay'
    end_card = 'end_card'
    pre_roll = 'pre_roll'
    companion = 'companion'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var audio
var companion
var end_card
var footer
var overlay
var pre_roll
var prominent
var subtitle

class Domain (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Domain(ScalarStr):
    __slots__ = ()
    _constraints = {
        'pattern': '^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
    }
    _json_schema_extra = {'description': 'A valid domain name'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Elevation (**data: Any)

Expand source code

class Elevation(AdCPBaseModel):
    __pydantic_extra__: Dict[str, str]
    model_config = ConfigDict(
        extra='allow',
    )
    none: Annotated[str | None, Field(description="No shadow (e.g., 'none')")] = None
    subtle: Annotated[
        str | None,
        Field(description="Subtle shadow for slight lift (e.g., '0 1px 2px rgba(0,0,0,0.05)')"),
    ] = None
    card: Annotated[
        str | None,
        Field(
            description="Card-level shadow (e.g., '0 4px 6px -1px rgba(0,0,0,0.1), 0 2px 4px -2px rgba(0,0,0,0.1)')"
        ),
    ] = None
    modal: Annotated[
        str | None,
        Field(
            description="Modal/overlay shadow (e.g., '0 20px 25px -5px rgba(0,0,0,0.1), 0 8px 10px -6px rgba(0,0,0,0.1)')"
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 card : str | None
var modal : str | None
var model_config
var none : str | None
var subtle : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class EmbeddedProvenanceItem (**data: Any)

Expand source code

class EmbeddedProvenanceItem(AdCPBaseModel):
    method: Annotated[
        EmbeddedProvenanceMethod,
        Field(description='How provenance data is carried within the content'),
    ]
    standard: Annotated[
        str | None,
        Field(
            description="Standard the embedding conforms to, if any (e.g., 'c2pa' for C2PA Section A.7 text manifest embedding)"
        ),
    ] = None
    provider: Annotated[
        str,
        Field(
            description="Organization that performed the embedding (e.g., 'Encypher', 'Digimarc'). Display label and audit context — not a wire identifier."
        ),
    ]
    verify_agent: Annotated[
        VerifyAgent | None,
        Field(
            description="Buyer's representation that this embedding can be verified by a governance agent on the seller's `creative_policy.accepted_verifiers` list. The `agent_url` MUST match (canonicalized) one of the seller's published `accepted_verifiers[].agent_url` entries; sellers reject `sync_creatives` submissions whose `verify_agent.agent_url` is off-list with `PROVENANCE_VERIFIER_NOT_ACCEPTED`. This is buyer-supplied evidence, not buyer-driven routing — the seller is the verifier-of-record and the seller controls which agent it actually calls (the seller MAY use a different on-list agent if it determines this is more appropriate; the seller does not call buyer-asserted endpoints outside its allowlist). MAY be omitted for self-verifiable embeddings (e.g., a C2PA text manifest with a public key the seller already trusts)."
        ),
    ] = None
    embedded_at: Annotated[
        AwareDatetime | None, Field(description='When the provenance data was embedded (ISO 8601)')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 embedded_at : pydantic.types.AwareDatetime | None
var method : EmbeddedProvenanceMethod
var model_config
var provider : str
var standard : str | None
var verify_agent : VerifyAgent | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class EmbeddedProvenanceMethod (*args, **kwds)

Expand source code

class EmbeddedProvenanceMethod(StrEnum):
    manifest_wrapper = 'manifest_wrapper'
    provenance_markers = 'provenance_markers'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var manifest_wrapper
var provenance_markers

class Ext (**data: Any)

Expand source code

class Ext(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Fallback (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class Fallback(ScalarStr):
    __slots__ = ()
    _constraints = {'max_length': 100}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class FeedFormat (*args, **kwds)

Expand source code

class FeedFormat(StrEnum):
    google_merchant_center = 'google_merchant_center'
    facebook_catalog = 'facebook_catalog'
    shopify = 'shopify'
    linkedin_jobs = 'linkedin_jobs'
    tiktok_shop = 'tiktok_shop'
    pinterest_catalog = 'pinterest_catalog'
    openai_product_feed = 'openai_product_feed'
    custom = 'custom'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var custom
var facebook_catalog
var google_merchant_center
var linkedin_jobs
var openai_product_feed
var pinterest_catalog
var shopify
var tiktok_shop

class FocalPointItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class FocalPointItem(ScalarFloat):
    __slots__ = ()
    _constraints = {'ge': 0.0, 'le': 1.0}

A float generated from a JSON Schema number root.

Strict, like the StrictFloat the generator emits for a type: number field: an int or float is accepted, a bool or numeric string is refused, matching the bundled JSON Schema validator.

Ancestors

adcp.types._scalar.ScalarFloat
adcp.types._scalar._ScalarRoot
builtins.float

class FontFile (**data: Any)

Expand source code

class FontFile(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[AnyUrl, Field(description='HTTPS URL to the font file (WOFF2, TTF, or OTF)')]
    weight: Annotated[
        SchemaInt | None,
        Field(description='CSS numeric font-weight for static fonts (100-900)', ge=100, le=900),
    ] = None
    weight_range: Annotated[
        list[WeightRangeItem] | None,
        Field(
            description='Variable font weight axis range as [min, max] (e.g., [100, 900]). Use instead of weight for variable fonts.',
            max_length=2,
            min_length=2,
        ),
    ] = None
    style: Annotated[Style | None, Field(description='CSS font-style')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 style : Style | None
var url : pydantic.networks.AnyUrl
var weight : int | None
var weight_range : list[WeightRangeItem] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class FontRole(RootModel[str | FontRole1]):
    root: Annotated[
        str | FontRole1,
        Field(
            description='A font role entry. Either a CSS font-family string (simple) or a structured object with family name and font files (rich).'
        ),
    ]
    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[str, FontRole1]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : str | FontRole1

class FontRole1 (**data: Any)

Expand source code

class FontRole1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    family: Annotated[str, Field(description="CSS font-family name (e.g., 'Brand Sans')")]
    files: Annotated[
        list[FontFile] | None,
        Field(description='Font files for different weights and styles', max_length=36),
    ] = None
    opentype_features: Annotated[
        list[OpentypeFeature] | None,
        Field(
            description="OpenType feature tags to enable (e.g., ['ss01', 'tnum', 'cv01']). These are four-character tags per the OpenType spec.",
            max_length=20,
        ),
    ] = None
    fallbacks: Annotated[
        list[Fallback] | None,
        Field(
            description="Ordered fallback font-family names for when the primary font is unavailable or does not support the required script (e.g., ['Noto Sans Arabic', 'Noto Sans SC', 'sans-serif'])",
            max_length=10,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 fallbacks : list[Fallback] | None
var family : str
var files : list[FontFile] | None
var model_config
var opentype_features : list[OpentypeFeature] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Fonts (**data: Any)

Expand source code

class Fonts(AdCPBaseModel):
    __pydantic_extra__: Dict[str, FontRole]
    model_config = ConfigDict(
        extra='allow',
    )
    primary: Annotated[FontRole | None, Field(description='Primary font family')] = None
    secondary: Annotated[FontRole | None, Field(description='Secondary font family')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : FontRole | None
var secondary : FontRole | 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',
    )
    subject_position: Annotated[
        str | None,
        Field(
            description="Where the subject sits in frame (e.g., 'center', 'center-left', 'rule-of-thirds')"
        ),
    ] = None
    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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    linear = 'linear'
    radial = 'radial'
    conic = 'conic'
    none = 'none'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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',
    )
    name: Annotated[
        str,
        Field(
            description="Element name (e.g., 'Paper Tear', 'Brand Watermark', 'Section Divider')"
        ),
    ]
    type: Annotated[Type1 | None, Field(description='Element type')] = None
    description: Annotated[str | None, Field(description='How the element is used in layouts')] = (
        None
    )
    orientation: Annotated[
        Orientation1 | None, Field(description='Preferred orientation when used in layouts')
    ] = None
    colors: Annotated[
        list[HexColor] | None, Field(description='Colors this element may appear in')
    ] = None
    max_per_layout: Annotated[
        SchemaInt | None, Field(description='Maximum instances per layout')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : Orientation1 | 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',
    )
    style_type: Annotated[StyleType | None, Field(description='Primary graphic style')] = 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
    corner_radius: Annotated[
        str | None,
        Field(
            description="Default corner radius for graphic and illustration elements (e.g., '12px', '8px', 'sharp'). For UI component radii (buttons, cards, inputs), see visual_guidelines.border_radius."
        ),
    ] = None
    tags: Annotated[list[str] | None, Field(description='Additional style descriptors')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class GuidelineSeverity(StrEnum):
    must = 'must'
    should = 'should'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var must
var should

class HexColor (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class HexColor(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^#[0-9A-Fa-f]{6}$'}
    _json_schema_extra = {'description': 'A single hex color value'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class House (**data: Any)

Expand source code

class House(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    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
    architecture: Annotated[
        Architecture | None,
        Field(
            description='Brand architecture model: branded_house (Google), house_of_brands (P&G), hybrid (Nike)'
        ),
    ] = None
    agents: Annotated[
        Agents | None,
        Field(
            description='House-level agents that apply to all brands unless overridden at the brand level'
        ),
    ] = None
    data_subject_contestation: Annotated[
        DataSubjectContestation | None,
        Field(
            description='House-level fallback contestation contact. Governance agents resolve in order: brand.data_subject_contestation → house.data_subject_contestation → missing (critical finding when human review required).'
        ),
    ] = None
    identity_relying_parties: Annotated[
        list[IdentityRelyingParty] | None,
        Field(
            description="Verified-identity relying parties this house/entity operates, so a buyer can verify that a forwarded TMP identity attestation's relying_party_id genuinely belongs to this entity (provenance) rather than being replayed under another owner. For network-as-RP, the network publishes its own relying_party_id here. See specs/tmp-verified-identity-attestation.md."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 agents : Agents | None
var architecture : Architecture | None
var data_subject_contestation : DataSubjectContestation | None
var domain : Domain
var identity_relying_parties : list[IdentityRelyingParty] | None
var model_config
var name : str
var names : list[LocalizedName] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class HumanOversight (*args, **kwds)

Expand source code

class HumanOversight(StrEnum):
    none = 'none'
    prompt_only = 'prompt_only'
    selected = 'selected'
    edited = 'edited'
    directed = 'directed'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var directed
var edited
var none
var prompt_only
var selected

class Iconography (**data: Any)

Expand source code

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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class IdentityRelyingParty(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    issuer: Annotated[
        BrandRef,
        Field(
            description='Identity issuer / attestation authority, referenced as a vendor BrandRef (e.g. {"domain": "world.org"}) — the same vendor-reference shape AdCP uses for measurement and signals vendors. The issuer\'s canonical domain is the anchor; it need not host a brand.json, but if it does, that is where its verifier metadata (scheme versions, verify endpoint, JWKs) lives. Issuer-agnostic: World ID, ISO 18013-5 mDL, and W3C-VC issuers all reference by domain. The relying party is namespaced by the issuer — identity is the tuple (issuer.domain, issuer.brand_id, relying_party_id), mirroring (vendor.domain, vendor.brand_id, metric_id).'
        ),
    ]
    scheme: Annotated[
        str | None, Field(description='Proof scheme and version, e.g. "world_id_v4".')
    ] = None
    relying_party_id: Annotated[
        str,
        Field(
            description="The relying-party id registered with the issuer (and, for on-chain issuers like World ID, with the issuer's registry). One entity may operate many relying parties (scope=entity vs scope=property); this is the attestation's audience / linkability boundary, not an entity identifier."
        ),
    ]
    scope: Annotated[
        Scope | None,
        Field(
            description="Whether this relying_party_id is shared across the entity's properties (entity → a within-entity unique-human graph) or scoped to a single property (property → per-property pseudonyms, unlinkable across the entity)."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 issuer : BrandRef
var model_config
var relying_party_id : str
var scheme : str | None
var scope : Scope | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ImageAsset (**data: Any)

Expand source code

class ImageAsset(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    asset_type: Annotated[
        Literal['image'],
        Field(
            description='Discriminator identifying this as an image asset. See /schemas/creative/asset-types for the registry.'
        ),
    ] = 'image'
    url: Annotated[AnyUrl, Field(description='URL to the image asset')]
    width: Annotated[SchemaInt, Field(description='Width in pixels', ge=1)]
    height: Annotated[SchemaInt, Field(description='Height in pixels', ge=1)]
    file_size_bytes: Annotated[
        SchemaInt | None,
        Field(
            description='Image file size in bytes. Required by agents that advertise a max_file_size_kb constraint.',
            ge=1,
        ),
    ] = None
    pixel_ratio: Annotated[
        StrictFloat | None,
        Field(
            description='Intrinsic pixels per logical render pixel (for example `2` for a 600×500 image intended to render at 300×250). Optional because a validator can infer the ratio when the target format declares logical dimensions. When supplied, it MUST agree with both `width / logical_width` and `height / logical_height`; it is never a substitute for the intrinsic `width` and `height` fields.',
            gt=0.0,
        ),
    ] = None
    state_id: Annotated[
        str | None,
        Field(
            description='Binding used only when this image populates a `seller_rendered_stateful_display` `state_canvases` slot. It MUST match one declared `states[].state_id` (semantic validators resolve it). Omit for ordinary image slots.'
        ),
    ] = None
    breakpoint_id: Annotated[
        str | None,
        Field(
            description='Binding used only when this image populates a `seller_rendered_stateful_display` `state_canvases` slot. It MUST match one breakpoint declared on the selected state (semantic validators resolve it). Omit for ordinary image slots.'
        ),
    ] = None
    focal_point: Annotated[
        list[FocalPointItem] | None,
        Field(
            description="Normalized `[x, y]` coordinates (0–1 from top-left) of the image's visual anchor. Seller-side renderers crop toward the focal point when deriving renditions across breakpoints and aspect ratios; absent, cropping falls back to center-weighted defaults.",
            max_length=2,
            min_length=2,
        ),
    ] = None
    format: Annotated[
        str | None, Field(description='Image file format (jpg, png, gif, webp, etc.)')
    ] = None
    alt_text: Annotated[str | None, Field(description='Alternative text for accessibility')] = None
    provenance: Annotated[
        Provenance | None,
        Field(
            description='Provenance metadata for this asset, overrides manifest-level provenance'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 alt_text : str | None
var asset_type : Literal['image']
var breakpoint_id : str | None
var file_size_bytes : int | None
var focal_point : list[FocalPointItem] | None
var format : str | None
var height : int
var model_config
var pixel_ratio : float | None
var provenance : Provenance | None
var state_id : str | None
var url : pydantic.networks.AnyUrl
var width : int

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Jurisdiction (**data: Any)

Expand source code

class Jurisdiction(AdCPBaseModel):
    country: Annotated[
        str, Field(description="ISO 3166-1 alpha-2 country code (e.g., 'US', 'DE', 'CN')")
    ]
    region: Annotated[
        str | None,
        Field(description="Sub-national region code (e.g., 'CA' for California, 'BY' for Bavaria)"),
    ] = None
    regulation: Annotated[
        str,
        Field(
            description="Regulation identifier (e.g., 'eu_ai_act_article_50', 'ca_sb_942', 'cn_deep_synthesis')"
        ),
    ]
    label_text: Annotated[
        str | None,
        Field(
            description='Required disclosure label text for this jurisdiction, in the local language'
        ),
    ] = None
    render_guidance: Annotated[
        RenderGuidance | None,
        Field(
            description="How the disclosure should be rendered for this jurisdiction. Expresses the declaring party's intent for persistence and position based on regulatory requirements. Publishers control actual rendering but governance agents can audit whether guidance was followed."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 country : str
var label_text : str | None
var model_config
var region : str | None
var regulation : str
var render_guidance : RenderGuidance | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class KellerType (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var endorsed
var independent
var master
var sub_brand

class Kind (*args, **kwds)

Expand source code

class Kind(StrEnum):
    name = 'name'
    value = 'value'
    surface = 'surface'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var name
var surface
var value

class LicenseType (*args, **kwds)

Expand source code

class LicenseType(StrEnum):
    owned = 'owned'
    licensed_in = 'licensed_in'
    licensed_out = 'licensed_out'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var licensed_in
var licensed_out
var owned

class LocaleTag (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class LocaleTag(ScalarStr):
    __slots__ = ()
    _constraints = {
        'max_length': 63,
        'min_length': 2,
        'pattern': '^(?:[a-z]{2,8}(?:-[A-Z][a-z]{3})?(?:-(?:[A-Z]{2}|[0-9]{3}))?(?:-(?:[a-z0-9]{5,8}|[0-9][a-z0-9]{3}))*(?:-[0-9a-wy-z](?:-[a-z0-9]{2,8})+)*(?:-x(?:-[a-z0-9]{1,8})+)?|x(?:-[a-z0-9]{1,8})+)$',
    }
    _json_schema_extra = {
        'description': 'A well-formed BCP 47 language tag used by AdCP only as language identity. Script and region may refine that identity; other valid BCP 47 subtags remain part of tag matching but do not make this a general locale-settings object. It does not determine currency, time zone, number/date formatting, market, or legal jurisdiction. The AdCP canonical wire profile requires lower-case language and variants, title-case script, and upper-case region (for example `en-US`, `zh-Hant-TW`, or `x-private`). RFC 5646 comparisons are case-insensitive and its case regularization is optional; AdCP intentionally requires this stricter single wire spelling and receivers MUST reject differently cased tags rather than silently normalizing them. The schema pattern enforces the AdCP casing profile and extension structure for commonly used tags; conforming receivers additionally validate the complete RFC 5646 grammar and registry rules. Every new AdCP field carrying BCP 47 language identity or a concrete language range MUST reference this schema instead of declaring independent string constraints.',
        'examples': ['en-US', 'es-ES', 'zh-Hant-TW', 'x-private'],
        'title': 'Language Tag',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

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

Expand source code

class LocalizedName(RootModel[dict[str, str]]):
    root: Annotated[dict[str, str], Field(max_length=1, 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 LocalizedScalar (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class LocalizedScalar(RootModel[str | LocalizedScalar1]):
    root: Annotated[
        str | LocalizedScalar1,
        Field(
            description="A legacy plain string or an ordered set of one-locale string maps. Producers MUST NOT repeat a locale after replacing '_' with '-' and applying the AdCP locale-tag canonicalization profile. Readers resolve the requested locale using the document default_language fallback contract and MUST NOT choose an arbitrary available translation."
        ),
    ]
    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[str, LocalizedScalar1]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : str | LocalizedScalar1

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

Expand source code

class LocalizedScalar1(RootModel[list[LocalizedName]]):
    root: Annotated[
        list[LocalizedName],
        Field(
            description="A legacy plain string or an ordered set of one-locale string maps. Producers MUST NOT repeat a locale after replacing '_' with '-' and applying the AdCP locale-tag canonicalization profile. Readers resolve the requested locale using the document default_language fallback contract and MUST NOT choose an arbitrary available translation.",
            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 LocalizedStringList (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class LocalizedStringList(RootModel[list[str] | LocalizedStringList1]):
    root: Annotated[
        list[str] | LocalizedStringList1,
        Field(
            description="A legacy plain string list or an ordered set of one-locale maps whose values are complete string lists. Producers MUST NOT repeat a locale after replacing '_' with '-' and applying the AdCP locale-tag canonicalization profile."
        ),
    ]
    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[list[str], LocalizedStringList1]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : list[str] | LocalizedStringList1

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

Expand source code

class LocalizedStringList1(RootModel[list[LocalizedStringListEntry]]):
    root: Annotated[
        list[LocalizedStringListEntry],
        Field(
            description="A legacy plain string list or an ordered set of one-locale maps whose values are complete string lists. Producers MUST NOT repeat a locale after replacing '_' with '-' and applying the AdCP locale-tag canonicalization profile.",
            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[LocalizedStringListEntry]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : list[LocalizedStringListEntry]

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

Expand source code

class LocalizedStringListEntry(RootModel[dict[str, list[str]]]):
    root: Annotated[dict[str, list[str]], Field(max_length=1, 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, list[str]]]
pydantic.root_model.RootModel
pydantic.main.BaseModel
typing.Generic

Class variables

var model_config
var root : dict[str, list[str]]

class LockupType (*args, **kwds)

Expand source code

class LockupType(StrEnum):
    co_brand = 'co_brand'
    secondary_mark = 'secondary_mark'
    partner = 'partner'
    sponsor = 'sponsor'
    program = 'program'
    talent = 'talent'
    custom = 'custom'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var co_brand
var custom
var partner
var program
var secondary_mark
var sponsor
var talent

class Logo (**data: Any)

Expand source code

class Logo(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    id: Annotated[
        LogoId | None,
        Field(
            description='Stable identifier for this logo entry. Recommended when logo usage rules or mark lockups need to bind to a specific logo asset.'
        ),
    ] = None
    url: Annotated[AnyUrl, Field(description='URL to the logo asset')]
    orientation: Annotated[
        Orientation | None,
        Field(
            description='Logo aspect ratio orientation. square: ~1:1, horizontal: wide, vertical: tall, stacked: vertically arranged elements'
        ),
    ] = None
    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
    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
    tags: Annotated[
        list[str] | None,
        Field(
            description='Additional semantic tags for custom categorization beyond the standard orientation, background, and variant fields'
        ),
    ] = None
    slots: Annotated[
        list[LogoSlot] | None,
        Field(
            description='Canonical renderer slots where this logo is appropriate. Consumers SHOULD prefer this over inferring from tags or usage prose when selecting a logo for a specific UI surface.'
        ),
    ] = None
    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
    width: Annotated[SchemaInt | None, Field(description='Width in pixels')] = None
    height: Annotated[SchemaInt | None, Field(description='Height in pixels')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 id : LogoId | None
var model_config
var orientation : Orientation | None
var slots : list[LogoSlot] | 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 LogoId (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class LogoId(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z0-9][a-z0-9_-]*$'}
    _json_schema_extra = {
        'description': 'Stable identifier for a logo entry within this brand.json document. Use lowercase words separated by underscores or hyphens; do not key integrations on mutable asset URLs.',
    }

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class LogoPlacement (**data: Any)

Expand source code

class LogoPlacement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    preferred_position: Annotated[
        PreferredPosition | None, Field(description='Preferred logo position in layouts')
    ] = 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
    background_contrast: Annotated[
        BackgroundContrast | None, Field(description='Permitted background contrast behind logo')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class LogoSlot(StrEnum):
    logo_card_light = 'logo_card_light'
    logo_card_dark = 'logo_card_dark'
    profile_mark = 'profile_mark'
    favicon = 'favicon'
    app_icon = 'app_icon'
    social_profile_mark = 'social_profile_mark'
    nav_header = 'nav_header'
    footer = 'footer'
    email_header = 'email_header'
    watermark = 'watermark'
    ad_end_card = 'ad_end_card'
    co_brand_lockup = 'co_brand_lockup'
    marketplace_listing = 'marketplace_listing'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var ad_end_card
var app_icon
var co_brand_lockup
var email_header
var favicon
var footer
var logo_card_dark
var logo_card_light
var marketplace_listing
var nav_header
var profile_mark
var social_profile_mark
var watermark

class LogoUsageRule (**data: Any)

Expand source code

class LogoUsageRule(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    logo_url: Annotated[
        AnyUrl | None,
        Field(
            description='Specific logo asset URL this rule applies to. Omit when the rule applies by variant or tags.'
        ),
    ] = None
    logo_id: Annotated[
        LogoId | None,
        Field(
            description='Stable `logos[].id` this rule applies to. Prefer this over logo_url when the rule targets a specific logo entry.'
        ),
    ] = None
    logo_variant: Annotated[
        Variant | None, Field(description='Logo variant this rule applies to.')
    ] = None
    logo_tags: Annotated[
        list[str] | None, Field(description='Logo tags this rule applies to.', min_length=1)
    ] = None
    contexts: Annotated[
        list[str] | None, Field(description='Creative contexts where this rule applies.')
    ] = None
    slots: Annotated[
        list[LogoSlot] | None,
        Field(
            description='Canonical renderer slots where this rule applies. Use this for deterministic logo-card, profile-mark, end-card, and lockup selection.',
            min_length=1,
        ),
    ] = None
    minimum_size: Annotated[
        MinimumSize | None, Field(description='Minimum rendered size needed for legibility.')
    ] = None
    clear_space: Annotated[
        str | None,
        Field(
            description='Minimum clear space around the logo, expressed in brand terms or units.'
        ),
    ] = None
    allowed_backgrounds: Annotated[
        list[ColorRef] | None,
        Field(
            description='Background color roles, values, or surfaces where this logo may be placed.'
        ),
    ] = None
    forbidden_backgrounds: Annotated[
        list[ColorRef] | None,
        Field(
            description='Background color roles, values, or surfaces where this logo must not be placed.'
        ),
    ] = None
    forbidden_contexts: Annotated[
        list[str] | None,
        Field(
            description='Contexts where this logo must not be used, such as photography_without_knockout.'
        ),
    ] = None
    severity: GuidelineSeverity | None = None
    description: Annotated[
        str | None,
        Field(description='Human-readable rationale or source-language summary for the rule.'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 allowed_backgrounds : list[ColorRef] | None
var clear_space : str | None
var contexts : list[str] | None
var description : str | None
var forbidden_backgrounds : list[ColorRef] | None
var forbidden_contexts : list[str] | None
var logo_id : LogoId | None
var logo_tags : list[str] | None
var logo_url : pydantic.networks.AnyUrl | None
var logo_variant : Variant | None
var minimum_size : MinimumSize | None
var model_config
var severity : GuidelineSeverity | None
var slots : list[LogoSlot] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MarkLockup (**data: Any)

Expand source code

class MarkLockup(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    lockup_type: Annotated[
        LockupType, Field(description='Type of mark relationship governed by this lockup rule.')
    ]
    ordering: Annotated[
        Ordering | None,
        Field(
            description='Required visual ordering of the brand mark relative to partner or secondary marks.'
        ),
    ] = None
    contexts: Annotated[
        list[str] | None, Field(description='Creative contexts where this lockup rule applies.')
    ] = None
    brand_logo_id: Annotated[
        LogoId | None,
        Field(
            description='Stable `logos[].id` for the brand logo this lockup rule is anchored on.'
        ),
    ] = None
    secondary_logo_ids: Annotated[
        list[LogoId] | None,
        Field(
            description='Stable `logos[].id` values for secondary, program, sponsor, or partner marks governed by this lockup rule when those marks are represented in this brand.json.'
        ),
    ] = None
    separator: Annotated[
        Separator | None, Field(description='Separator between marks, when required.')
    ] = None
    min_gap: Annotated[
        str | None,
        Field(description='Minimum gap between marks, expressed in brand terms or units.'),
    ] = None
    brand_min_optical_weight_ratio: Annotated[
        StrictFloat | None,
        Field(
            description='Minimum optical weight of the brand mark relative to partner marks. 1 means at least equal.',
            gt=0.0,
        ),
    ] = None
    partner_max_optical_weight_ratio: Annotated[
        StrictFloat | None,
        Field(
            description='Maximum optical weight of partner marks relative to the brand mark. 1 means no larger than the brand mark. Enforcement is at layout time, not parse time — this value signals to renderers and creative agents how much space to provision for each mark.',
            gt=0.0,
        ),
    ] = None
    severity: GuidelineSeverity | None = None
    description: Annotated[
        str | None,
        Field(
            description='Human-readable rationale or source-language summary for the lockup rule.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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_logo_id : LogoId | None
var brand_min_optical_weight_ratio : float | None
var contexts : list[str] | None
var description : str | None
var lockup_type : LockupType
var min_gap : str | None
var model_config
var ordering : Ordering | None
var partner_max_optical_weight_ratio : float | None
var secondary_logo_ids : list[LogoId] | None
var separator : Separator | None
var severity : GuidelineSeverity | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class MinimumSize (**data: Any)

Expand source code

class MinimumSize(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    width: Annotated[str | None, Field(description='Minimum width, such as 48px or 12mm.')] = None
    height: Annotated[str | None, Field(description='Minimum height, such as 18px or 6mm.')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : str | None
var model_config
var width : str | 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',
    )
    transition_style: Annotated[
        TransitionStyle | None, Field(description='Primary transition style between scenes')
    ] = None
    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
    text_entrance: Annotated[
        TextEntrance | None, Field(description='How text enters the frame')
    ] = None
    pacing: Annotated[Pacing | None, Field(description='Overall editing rhythm')] = None
    kinetic_typography: Annotated[
        StrictBool | None, Field(description='Whether animated/kinetic typography is allowed')
    ] = None
    tags: Annotated[list[str] | None, Field(description='Additional motion style descriptors')] = (
        None
    )

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 NiceClass (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class NiceClass(ScalarInt):
    __slots__ = ()
    _constraints = {'ge': 1, 'le': 45}

An int generated from a JSON Schema integer root.

Validates the way SchemaInt validates an integer field: strict, so "1" and True are refused, with a float carrying no fractional part narrowed to int because JSON Schema counts it as one.

Ancestors

adcp.types._scalar.ScalarInt
adcp.types._scalar._ScalarRoot
builtins.int

class OpentypeFeature (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class OpentypeFeature(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[a-z0-9]{4}$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class Ordering (*args, **kwds)

Expand source code

class Ordering(StrEnum):
    brand_first = 'brand_first'
    partner_first = 'partner_first'
    equal = 'equal'
    contextual = 'contextual'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var brand_first
var contextual
var equal
var partner_first

class Orientation (*args, **kwds)

Expand source code

class Orientation(StrEnum):
    square = 'square'
    horizontal = 'horizontal'
    vertical = 'vertical'
    stacked = 'stacked'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var horizontal
var square
var stacked
var vertical

class Orientation1 (*args, **kwds)

Expand source code

class Orientation1(StrEnum):
    horizontal = 'horizontal'
    vertical = 'vertical'
    any = 'any'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var any
var horizontal
var vertical

class Overlays (**data: Any)

Expand source code

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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    lingering = 'lingering'
    moderate = 'moderate'
    fast_cuts = 'fast_cuts'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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',
    )
    name: Annotated[str, Field(description='Palette name')]
    colors: Annotated[
        dict[str, HexColor], Field(description='Map of role names to hex color values')
    ]

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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',
    )
    realism: Annotated[Realism | None, Field(description='Level of photographic realism')] = None
    lighting: Annotated[
        str | None,
        Field(
            description="Lighting style (e.g., 'soft daylight', 'studio', 'golden hour', 'high-key', 'low-key')"
        ),
    ] = None
    color_temperature: Annotated[
        ColorTemperature | None, Field(description='Overall color temperature of photography')
    ] = None
    contrast: Annotated[Contrast | 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
    subject: Annotated[Subject | None, Field(description='Subject matter guidelines')] = None
    framing: Annotated[Framing | None, Field(description='Camera framing rules')] = 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
    tags: Annotated[list[str] | None, Field(description='Additional style descriptors')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class PortfolioEntry(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    domain: Annotated[
        Domain, Field(description="Domain where the child's canonical brand.json lives")
    ]
    brand_id: Annotated[
        BrandId,
        Field(
            description='Stable brand identifier within the house portfolio. Required so the cross-array uniqueness invariant (brand_id MUST NOT appear in both brands[] and brand_refs[]) is enforceable.'
        ),
    ]
    managed_by: Annotated[
        Domain | None,
        Field(
            description="Optional domain of the entity that operationally manages this brand (e.g., an agency network within a holdco). House-declared. Consumers MUST NOT use it for trust or authorization decisions. Aggregation across houses ('show me everything BBH manages') is the intended use; trust is unaffected."
        ),
    ] = None
    effective_at: Annotated[
        AwareDatetime | None,
        Field(
            description='ISO 8601 timestamp when the house established this ownership claim. Consumers age mutual-assertion edges from this date for TTL purposes and MUST NOT extend relationship trust before a future effective_at is reached. Optional; absent means the consumer ages from its own durable first observation.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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_id : BrandId
var domain : Domain
var effective_at : pydantic.types.AwareDatetime | None
var managed_by : Domain | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class PreferredAspectRatio (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class PreferredAspectRatio(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^\\d+:\\d+$'}

A str generated from a JSON Schema string root.

Ancestors

adcp.types._scalar.ScalarStr
adcp.types._scalar._ScalarRoot
builtins.str

class PreferredPosition (*args, **kwds)

Expand source code

class PreferredPosition(StrEnum):
    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'  # type: ignore[assignment]

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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',
    )
    feed_url: Annotated[AnyUrl, Field(description='URL to product catalog feed')]
    feed_format: Annotated[FeedFormat | None, Field(description='Format of the product feed')] = (
        None
    )
    categories: Annotated[
        list[str] | None, Field(description='Product categories available in the catalog')
    ] = None
    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
    agentic_checkout: Annotated[
        AgenticCheckout | None, Field(description='Agentic checkout endpoint configuration')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    in_use = 'in-use'
    isolated = 'isolated'
    lifestyle = 'lifestyle'
    detail = 'detail'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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',
    )
    type: Annotated[PropertyType, Field(description='Property type')]
    identifier: Annotated[
        str,
        Field(
            description='Property identifier - domain for websites, bundle ID for apps',
            min_length=1,
        ),
    ]
    store: Annotated[Store | None, Field(description='App store for mobile/CTV apps')] = None
    region: Annotated[
        str | None,
        Field(
            description="ISO 3166-1 alpha-2 country code or 'global'", pattern='^([A-Z]{2}|global)$'
        ),
    ] = None
    primary: Annotated[
        StrictBool | None, Field(description='Whether this is the primary property for the brand')
    ] = False
    relationship: Annotated[
        Relationship | None,
        Field(
            description="How this brand relates to the property. 'owned': the brand owns and operates this property (default) and has no adagents.json delegation_type counterpart. 'direct': the brand is the direct sales path for this property, even if a third party operates the software (e.g., a publisher's in-house ad team using a vendor's tech). 'delegated': the brand manages monetization for this property — they are in charge of ad sales (e.g., Mediavine managing a food blog). 'ad_network': the brand sells this property's inventory as part of a network or exchange — they are a path to the inventory, not the path (e.g., PubMatic as an SSP). For non-owned properties, the publisher confirms the relationship by setting the matching delegation_type on the agent's authorization in their adagents.json."
        ),
    ] = Relationship.owned

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 relationship : Relationship | None
var store : Store | None
var type : PropertyType

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class PropertyType (*args, **kwds)

Expand source code

class PropertyType(StrEnum):
    website = 'website'
    mobile_app = 'mobile_app'
    ctv_app = 'ctv_app'
    desktop_app = 'desktop_app'
    dooh = 'dooh'
    podcast = 'podcast'
    radio = 'radio'
    linear_tv = 'linear_tv'
    streaming_audio = 'streaming_audio'
    ai_assistant = 'ai_assistant'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var ai_assistant
var ctv_app
var desktop_app
var dooh
var linear_tv
var mobile_app
var podcast
var radio
var streaming_audio
var website

class Provenance (**data: Any)

Expand source code

class Provenance(AdCPBaseModel):
    digital_source_type: Annotated[
        DigitalSourceType | None,
        Field(
            description='IPTC-aligned classification of AI involvement in producing this content'
        ),
    ] = None
    synthetic_depiction: Annotated[
        StrictBool | None,
        Field(
            description='Assessed declaration of whether the content synthetically depicts a real or fictional person performing or appearing in a way that was generated or materially manipulated rather than captured as depicted. `true` covers both a fully synthetic performer and material manipulation of a real performer; `false` is an assessed declaration that the content does not contain such a depiction. Absence means the content has not been assessed for synthetic depiction. This field does not claim consent, legality, or independent verification, and receivers MUST NOT derive it solely from `digital_source_type`.'
        ),
    ] = None
    ai_tool: Annotated[
        AiTool | None,
        Field(
            description='AI system used to generate or modify this content. Aligns with IPTC 2025.1 AI metadata fields and C2PA claim_generator.'
        ),
    ] = None
    human_oversight: Annotated[
        HumanOversight | None,
        Field(
            description='Level of human involvement in the AI-assisted creation process. Independent of `disclosure.required` — the protocol does not derive disclosure obligations from oversight level. Some regulations include carve-outs for human-edited or human-directed AI output, but those carve-outs have factual prerequisites the schema cannot evaluate. Asserting `edited` or `directed` does not by itself justify `disclosure.required: false`.'
        ),
    ] = None
    declared_by: Annotated[
        DeclaredBy | None,
        Field(
            description='Party declaring this provenance. Identifies who attached the provenance claim, enabling receiving parties to assess trust.'
        ),
    ] = None
    declared_at: Annotated[
        AwareDatetime | None,
        Field(
            description='When this provenance claim was made (ISO 8601). Distinct from created_time, which records when the content itself was produced. A provenance claim may be attached well after content creation, for example when retroactively declaring AI involvement for regulatory compliance.'
        ),
    ] = None
    created_time: Annotated[
        AwareDatetime | None,
        Field(description='When this content was created or generated (ISO 8601)'),
    ] = None
    c2pa: Annotated[
        C2pa | None,
        Field(
            description='C2PA sidecar manifest reference. Links to a detached cryptographic provenance manifest for this content. Note: file-level C2PA bindings break when ad servers transcode, resize, or re-encode assets. For pipelines with intermediaries, consider embedded_provenance as the primary provenance mechanism.'
        ),
    ] = None
    embedded_provenance: Annotated[
        list[EmbeddedProvenanceItem] | None,
        Field(
            description='Provenance metadata embedded within the content stream. Each entry declares one embedding layer: structured provenance data carried inside the content itself, as distinct from sidecar references (c2pa.manifest_url). Embedded provenance survives operations that break sidecar and file-level bindings: ad-server transcoding, CMS ingestion, copy-paste, reformatting, and CDN re-encoding. For ad-tech pipelines where content passes through multiple intermediaries, embedded provenance is the reliable path for provenance that persists from declaration through delivery. This is a declaration by the embedding party. The receiving party (the seller) is the verifier-of-record: it confirms the claim by calling a governance agent it trusts (typically one published in `creative_policy.accepted_verifiers`).',
            min_length=1,
        ),
    ] = None
    watermarks: Annotated[
        list[Watermark] | None,
        Field(
            description='Content watermarks applied to this asset. Each entry declares one watermarking layer: a content modification that encodes an identifier or fingerprint within the asset. Watermarks differ from embedded provenance: a watermark encodes an identifier (who generated it, who owns it), while embedded provenance carries or references a structured provenance record (the full chain of custody). A single asset may carry both. Aligns with C2PA action taxonomy: c2pa.watermarked.bound (watermark linked to a C2PA manifest) and c2pa.watermarked.unbound (watermark independent of any manifest). This is a declaration by the watermarking party. The receiving party (the seller) is the verifier-of-record: it confirms the claim by calling a governance agent it trusts (typically one published in `creative_policy.accepted_verifiers`).',
            min_length=1,
        ),
    ] = None
    disclosure: Annotated[
        Disclosure | None,
        Field(
            description='Regulatory disclosure requirements for this content. Indicates whether AI disclosure is required and under which jurisdictions.'
        ),
    ] = None
    verification: Annotated[
        list[VerificationItem] | None,
        Field(
            description='Third-party verification or detection results for this content. Multiple services may independently evaluate the same content. Provenance is a claim — verification results attached by the declaring party are supplementary. The enforcing party (e.g., seller/publisher) should run its own verification via get_creative_features or calibrate_content.',
            min_length=1,
        ),
    ] = None
    ext: Ext | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 ai_tool : AiTool | None
var c2pa : C2pa | None
var created_time : pydantic.types.AwareDatetime | None
var declared_at : pydantic.types.AwareDatetime | None
var declared_by : DeclaredBy | None
var digital_source_type : DigitalSourceType | None
var disclosure : Disclosure | None
var embedded_provenance : list[EmbeddedProvenanceItem] | None
var ext : Ext | None
var human_oversight : HumanOversight | None
var model_config
var synthetic_depiction : bool | None
var verification : list[VerificationItem] | None
var watermarks : list[Watermark] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Realism (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var abstract
var hyperreal
var natural
var stylized

class RedirectReason (*args, **kwds)

Expand source code

class RedirectReason(StrEnum):
    acquisition = 'acquisition'
    divestiture = 'divestiture'
    rebrand = 'rebrand'
    regional = 'regional'
    legacy = 'legacy'
    consolidation = 'consolidation'
    other = 'other'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var acquisition
var consolidation
var divestiture
var legacy
var other
var rebrand
var regional

class Relationship (*args, **kwds)

Expand source code

class Relationship(StrEnum):
    owned = 'owned'
    direct = 'direct'
    delegated = 'delegated'
    ad_network = 'ad_network'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var ad_network
var delegated
var direct
var owned

class RenderGuidance (**data: Any)

Expand source code

class RenderGuidance(AdCPBaseModel):
    persistence: Annotated[
        DisclosurePersistence | None,
        Field(
            description='How long the disclosure must persist during content playback or display'
        ),
    ] = None
    min_duration_ms: Annotated[
        SchemaInt | None,
        Field(
            description="Minimum display duration in milliseconds for initial persistence. Recommended when persistence is initial — without it, the duration is at the publisher's discretion. At serve time the publisher reads this from provenance since the brief is not available.",
            ge=1,
        ),
    ] = None
    positions: Annotated[
        list[DisclosurePosition] | None,
        Field(
            description='Preferred disclosure positions in priority order. The first position a format supports should be used.',
            min_length=1,
        ),
    ] = None
    ext: Ext | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 ext : Ext | None
var min_duration_ms : int | None
var model_config
var persistence : DisclosurePersistence | None
var positions : list[DisclosurePosition] | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Result (*args, **kwds)

Expand source code

class Result(StrEnum):
    authentic = 'authentic'
    ai_generated = 'ai_generated'
    ai_modified = 'ai_modified'
    inconclusive = 'inconclusive'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var ai_generated
var ai_modified
var authentic
var inconclusive

class RightType (*args, **kwds)

Expand source code

class RightType(StrEnum):
    talent = 'talent'
    character = 'character'
    brand_ip = 'brand_ip'
    music = 'music'
    stock_media = 'stock_media'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var brand_ip
var character
var music
var stock_media
var talent

class RightUse (*args, **kwds)

Expand source code

class RightUse(StrEnum):
    likeness = 'likeness'
    voice = 'voice'
    name = 'name'
    endorsement = 'endorsement'
    motion_capture = 'motion_capture'
    signature = 'signature'
    catchphrase = 'catchphrase'
    sync = 'sync'
    background_music = 'background_music'
    editorial = 'editorial'
    commercial = 'commercial'
    ai_generated_image = 'ai_generated_image'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var ai_generated_image
var background_music
var catchphrase
var commercial
var editorial
var endorsement
var likeness
var motion_capture
var name
var signature
var sync
var voice

class RightsAgent (**data: Any)

Expand source code

class RightsAgent(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    url: Annotated[
        AnyUrl,
        Field(
            description="Rights agent MCP endpoint URL. Callers comparing this URL against another value (e.g., matching against a brand's declared rights endpoint) MUST canonicalize both sides per the AdCP URL canonicalization rules, not byte-equality. See docs/reference/url-canonicalization."
        ),
    ]
    id: Annotated[str, Field(description='Agent identifier', pattern='^[a-z0-9_]+$')]
    available_uses: Annotated[
        list[RightUse],
        Field(description='Rights uses available for licensing through this agent', min_length=1),
    ]
    right_types: Annotated[
        list[RightType] | None, Field(description='Types of rights available', min_length=1)
    ] = None
    countries: Annotated[
        list[Country1] | None,
        Field(description='Countries where rights are available (ISO 3166-1 alpha-2)'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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[Country1] | 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 Role (*args, **kwds)

Expand source code

class Role(StrEnum):
    creator = 'creator'
    advertiser = 'advertiser'
    agency = 'agency'
    platform = 'platform'
    tool = 'tool'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var advertiser
var agency
var creator
var platform
var tool

class Scale (**data: Any)

Expand source code

class Scale(AdCPBaseModel):
    __pydantic_extra__: Dict[str, str]
    model_config = ConfigDict(
        extra='allow',
    )
    xs: Annotated[str | None, Field(description="Extra small spacing (e.g., '4px')")] = None
    sm: Annotated[str | None, Field(description="Small spacing (e.g., '8px')")] = None
    md: Annotated[str | None, Field(description="Medium spacing (e.g., '16px')")] = None
    lg: Annotated[str | None, Field(description="Large spacing (e.g., '24px')")] = None
    xl: Annotated[str | None, Field(description="Extra large spacing (e.g., '32px')")] = None
    field_2xl: Annotated[
        str | None, Field(alias='2xl', description="Section-level spacing (e.g., '48px', '64px')")
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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_2xl : str | None
var lg : str | None
var md : str | None
var model_config
var sm : str | None
var xl : str | None
var xs : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Scope (*args, **kwds)

Expand source code

class Scope(StrEnum):
    entity = 'entity'
    property = 'property'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var entity
var property

class Scope1 (*args, **kwds)

Expand source code

class Scope1(StrEnum):
    all = 'all'
    media_buying = 'media_buying'
    creative_generation = 'creative_generation'
    rights_clearance = 'rights_clearance'
    governance = 'governance'
    measurement = 'measurement'
    agent_operations = 'agent_operations'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var agent_operations
var all
var creative_generation
var governance
var measurement
var media_buying
var rights_clearance

class Separator (**data: Any)

Expand source code

class Separator(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    type: Annotated[Type, Field(description='Separator style.')]
    color: ColorRef | None = None
    width: Annotated[str | None, Field(description='Separator width, such as 1px.')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : ColorRef | None
var model_config
var type : Type
var width : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Spacing (**data: Any)

Expand source code

class Spacing(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    unit: Annotated[
        str | None,
        Field(
            description="Base grid unit this scale was designed from (e.g., '8px', '4px'). Informational — agents should use the named scale values, not compute from this."
        ),
    ] = None
    scale: Annotated[
        Scale | None, Field(description='Named spacing scale built from the base unit')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 scale : Scale | None
var unit : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Status (*args, **kwds)

Expand source code

class Status(StrEnum):
    active = 'active'
    pending = 'pending'
    abandoned = 'abandoned'
    cancelled = 'cancelled'
    expired = 'expired'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var abandoned
var active
var cancelled
var expired
var pending

class Store (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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(StrEnum):
    rounded = 'rounded'
    square = 'square'
    mixed = 'mixed'
    none = 'none'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var mixed
var none
var rounded
var square

class Style (*args, **kwds)

Expand source code

class Style(StrEnum):
    normal = 'normal'
    italic = 'italic'
    oblique = 'oblique'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var italic
var normal
var oblique

class Style1 (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var duotone
var filled
var flat
var glyph
var hand_drawn
var outline

class Style2 (*args, **kwds)

Expand source code

class Style2(StrEnum):
    none = 'none'
    subtle_grain = 'subtle_grain'
    noise = 'noise'
    paper = 'paper'
    fabric = 'fabric'
    concrete = 'concrete'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var concrete
var fabric
var noise
var none
var paper
var subtle_grain

class StyleType (*args, **kwds)

Expand source code

class StyleType(StrEnum):
    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'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Expand source code

class Surface(StrEnum):
    background = 'background'
    foreground = 'foreground'
    text = 'text'
    logo_background = 'logo_background'
    cta = 'cta'
    accent = 'accent'
    border = 'border'
    icon = 'icon'
    graphic_element = 'graphic_element'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var accent
var background
var border
var cta
var foreground
var graphic_element
var icon
var logo_background
var text

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

Expand source code

class TalentRole(StrEnum):
    host = 'host'
    guest = 'guest'
    creator = 'creator'
    cast = 'cast'
    narrator = 'narrator'
    producer = 'producer'
    correspondent = 'correspondent'
    commentator = 'commentator'
    analyst = 'analyst'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var analyst
var cast
var commentator
var correspondent
var creator
var guest
var host
var narrator
var producer

class TextEntrance (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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(StrEnum):
    none = 'none'
    uppercase = 'uppercase'
    lowercase = 'lowercase'
    capitalize = 'capitalize'  # type: ignore[assignment]

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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',
    )
    style: Annotated[
        Style2 | None, Field(description='Texture style applied to creative assets')
    ] = None
    intensity: Annotated[Contrast | None, Field(description='Texture intensity')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : Contrast | None
var model_config
var style : Style2 | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Tone (**data: Any)

Expand source code

class Tone(AdCPBaseModel):
    voice: Annotated[
        LocalizedScalar | None,
        Field(
            description='High-level voice descriptor, either a legacy plain string or localized values.'
        ),
    ] = None
    attributes: Annotated[
        LocalizedStringList | None,
        Field(
            description='Personality traits that characterize the brand voice. Localized lists are selected as a whole.'
        ),
    ] = None
    dos: Annotated[
        LocalizedStringList | None,
        Field(
            description='Guidance for copy generation - what TO do. Localized lists are selected as a whole.'
        ),
    ] = None
    donts: Annotated[
        LocalizedStringList | None,
        Field(
            description='Guardrails to avoid brand violations - what NOT to do. Localized lists are selected as a whole.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 : LocalizedStringList | None
var donts : LocalizedStringList | None
var dos : LocalizedStringList | None
var model_config
var voice : LocalizedScalar | 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',
    )
    registry: Annotated[
        str, Field(description="Trademark registry (e.g., 'USPTO', 'EUIPO', 'JPO', 'CNIPA')")
    ]
    number: Annotated[str, Field(description='Registration number as issued by the registry')]
    mark: Annotated[str, Field(description='The registered mark as published')]
    status: Annotated[
        Status | None,
        Field(
            description='Registration status. Omit for active marks if status tracking is not maintained.'
        ),
    ] = None
    license_type: Annotated[
        LicenseType | None,
        Field(
            description="Whether the publisher owns the mark, licenses it from another entity, or licenses it to others. 'owned' is the default if omitted."
        ),
    ] = None
    licensor_domain: Annotated[
        Domain | None,
        Field(
            description='Domain of the entity that licenses this mark to the publisher. Meaningful when license_type=licensed_in; omit otherwise.'
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description="ISO 3166-1 alpha-2 country codes where this registration applies. Omit for global or where the registry's jurisdiction is implicit."
        ),
    ] = None
    nice_classes: Annotated[
        list[NiceClass] | None,
        Field(
            description='Nice Classification class numbers (1-45) covered by this registration. Disambiguates marks across industries (e.g., Delta-airline vs Delta-faucet). Omit if scope is implicit from registry.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 countries : list[Country] | None
var license_type : LicenseType | None
var licensor_domain : Domain | None
var mark : str
var model_config
var nice_classes : list[NiceClass] | None
var number : str
var registry : str
var status : Status | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class TransitionStyle (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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(StrEnum):
    none = 'none'
    keyline = 'keyline'
    space = 'space'
    divider = 'divider'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var divider
var keyline
var none
var space

class Type1 (*args, **kwds)

Expand source code

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

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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(StrEnum):
    icon_set = 'icon_set'
    illustration_system = 'illustration_system'
    image_library = 'image_library'
    video_library = 'video_library'
    template_library = 'template_library'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var icon_set
var illustration_system
var image_library
var template_library
var video_library

class TypeScale (**data: Any)

Expand source code

class TypeScale(AdCPBaseModel):
    __pydantic_extra__: Dict[str, TypeScaleEntry]
    model_config = ConfigDict(
        extra='allow',
    )
    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
    heading: TypeScaleEntry | None = None
    subheading: TypeScaleEntry | None = None
    body: TypeScaleEntry | None = None
    caption: TypeScaleEntry | None = None
    cta: TypeScaleEntry | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 reference. Use a key from the fonts object (e.g., 'primary', 'secondary') to reference a defined font role, or a literal CSS font-family string as a fallback."
        ),
    ] = None
    size: Annotated[str | None, Field(description="Font size (e.g., '48px', '2rem')")] = None
    weight: Annotated[str | None, Field(description="Font weight (e.g., '700', 'bold')")] = None
    line_height: Annotated[str | None, Field(description="Line height (e.g., '1.2', '56px')")] = (
        None
    )
    letter_spacing: Annotated[
        str | None, Field(description="Letter spacing (e.g., '-0.02em', '0.5px')")
    ] = None
    text_transform: Annotated[TextTransform | None, Field(description='Text transformation')] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    solid_color = 'solid_color'
    gradient = 'gradient'
    blurred_photo = 'blurred_photo'
    image = 'image'
    video = 'video'
    pattern = 'pattern'
    transparent = 'transparent'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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(StrEnum):
    realtime = 'realtime'
    hourly = 'hourly'
    daily = 'daily'
    weekly = 'weekly'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
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[
        SchemaInt | None, Field(description='Maximum distinct shapes per layout')
    ] = None
    overlap_allowed: Annotated[
        StrictBool | None, Field(description='Whether shapes may overlap')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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(StrEnum):
    primary = 'primary'
    secondary = 'secondary'
    icon = 'icon'
    wordmark = 'wordmark'
    full_lockup = 'full-lockup'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var full_lockup
var icon
var primary
var secondary
var wordmark

class VerificationItem (**data: Any)

Expand source code

class VerificationItem(AdCPBaseModel):
    verified_by: Annotated[
        str,
        Field(
            description="Name of the verification service (e.g., 'DoubleVerify', 'Hive Moderation', 'Reality Defender')"
        ),
    ]
    verified_time: Annotated[
        AwareDatetime | None, Field(description='When the verification was performed (ISO 8601)')
    ] = None
    result: Annotated[Result, Field(description='Verification outcome')]
    confidence: Annotated[
        StrictFloat | None,
        Field(
            description='Confidence score of the verification result (0.0 to 1.0)', ge=0.0, le=1.0
        ),
    ] = None
    details_url: Annotated[
        AnyUrl | None, Field(description='URL to the full verification report')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 confidence : float | None
var details_url : pydantic.networks.AnyUrl | None
var model_config
var result : Result
var verified_by : str
var verified_time : pydantic.types.AwareDatetime | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyAgent (**data: Any)

Expand source code

class VerifyAgent(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    agent_url: Annotated[
        AnyUrl,
        Field(
            description="URL of the governance agent the buyer represents was used to embed/verify this layer. MUST use the `https://` scheme and MUST appear in the seller's `creative_policy.accepted_verifiers[].agent_url` list (canonicalized per /docs/reference/url-canonicalization: lowercase scheme and host, strip default port, normalize path dot-segments). Sellers MUST NOT call this URL until the canonicalized match is confirmed."
        ),
    ]
    feature_id: Annotated[
        str | None,
        Field(
            description="Optional `feature_id` the buyer represents the seller should request via `get_creative_features` (e.g., `encypher.markers_present_v2`). SHOULD match the `feature_id` declared on the matching `accepted_verifiers[]` entry, or be omitted to defer the selector to the seller. When the seller's entry pins a `feature_id`, that value wins; when neither side pins, the seller selects from the agent's `governance.creative_features` catalog."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 agent_url : pydantic.networks.AnyUrl
var feature_id : str | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyAgent1 (**data: Any)

Expand source code

class VerifyAgent1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    agent_url: Annotated[
        AnyUrl,
        Field(
            description="URL of the governance agent the buyer represents was used to apply/detect this watermark. MUST use the `https://` scheme and MUST appear in the seller's `creative_policy.accepted_verifiers[].agent_url` list (canonicalized per /docs/reference/url-canonicalization: lowercase scheme and host, strip default port, normalize path dot-segments). Sellers MUST NOT call this URL until the canonicalized match is confirmed."
        ),
    ]
    feature_id: Annotated[
        str | None,
        Field(
            description="Optional `feature_id` the buyer represents the seller should request via `get_creative_features` (e.g., `imatag.watermark_detected`). SHOULD match the `feature_id` declared on the matching `accepted_verifiers[]` entry, or be omitted to defer the selector to the seller. When the seller's entry pins a `feature_id`, that value wins; when neither side pins, the seller selects from the agent's `governance.creative_features` catalog."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 agent_url : pydantic.networks.AnyUrl
var feature_id : str | None
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VisualGuidelines (**data: Any)

Expand source code

class VisualGuidelines(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    photography: PhotographyStyle | None = None
    graphic_style: GraphicStyle | None = None
    shapes: BrandShapes | None = None
    iconography: Iconography | None = None
    composition: CompositionRules | None = None
    border_radius: BorderRadius | None = None
    elevation: Elevation | None = None
    spacing: Spacing | 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
    motion: MotionGuidelines | None = None
    logo_placement: LogoPlacement | None = None
    colorways: Annotated[
        list[Colorway] | None,
        Field(description='Named color pairings for consistent foreground/background combinations'),
    ] = None
    color_constraints: Annotated[
        list[ColorConstraint] | None,
        Field(
            description='Machine-readable constraints for color usage and pairings, such as accent-only rules or forbidden foreground/background combinations.'
        ),
    ] = None
    logo_usage_rules: Annotated[
        list[LogoUsageRule] | None,
        Field(
            description='Machine-readable logo selection and placement constraints for minimum size, clear space, backgrounds, and contexts.'
        ),
    ] = None
    mark_lockups: Annotated[
        list[MarkLockup] | None,
        Field(
            description='Machine-readable co-brand, partner, sponsor, program, or secondary-mark lockup rules.'
        ),
    ] = 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
    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
    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

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 border_radius : BorderRadius | None
var color_constraints : list[ColorConstraint] | None
var colorways : list[Colorway] | None
var composition : CompositionRules | None
var elevation : Elevation | None
var graphic_elements : list[GraphicElement] | None
var graphic_style : GraphicStyle | None
var iconography : Iconography | None
var logo_placement : LogoPlacement | None
var logo_usage_rules : list[LogoUsageRule] | None
var mark_lockups : list[MarkLockup] | None
var model_config
var motion : MotionGuidelines | None
var photography : PhotographyStyle | None
var restrictions : list[str] | None
var shapes : BrandShapes | None
var spacing : Spacing | 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
    voice_id: str | None = None
    settings: dict[str, Any] | None = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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

class Watermark (**data: Any)

Expand source code

class Watermark(AdCPBaseModel):
    media_type: Annotated[
        WatermarkMediaType, Field(description='Media category of the watermarked content')
    ]
    provider: Annotated[
        str,
        Field(
            description="Organization that applied the watermark (e.g., 'Imatag', 'Steg.AI', 'Encypher'). Display label and audit context — not a wire identifier."
        ),
    ]
    verify_agent: Annotated[
        VerifyAgent1 | None,
        Field(
            description="Buyer's representation that this watermark can be detected by a governance agent on the seller's `creative_policy.accepted_verifiers` list. The `agent_url` MUST match (canonicalized) one of the seller's published `accepted_verifiers[].agent_url` entries; sellers reject `sync_creatives` submissions whose `verify_agent.agent_url` is off-list with `PROVENANCE_VERIFIER_NOT_ACCEPTED`. This is buyer-supplied evidence, not buyer-driven routing — the seller is the verifier-of-record and the seller controls which agent it actually calls (the seller MAY use a different on-list agent if it determines this is more appropriate; the seller does not call buyer-asserted endpoints outside its allowlist)."
        ),
    ] = None
    c2pa_action: Annotated[
        C2paWatermarkAction | None,
        Field(description='C2PA action classification for this watermark'),
    ] = None
    embedded_at: Annotated[
        AwareDatetime | None, Field(description='When the watermark was applied (ISO 8601)')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Important

Consumers who want per-model strict validation can override model_config on their subclass.

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 c2pa_action : C2paWatermarkAction | None
var embedded_at : pydantic.types.AwareDatetime | None
var media_type : WatermarkMediaType
var model_config
var provider : str
var verify_agent : VerifyAgent1 | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class WatermarkMediaType (*args, **kwds)

Expand source code

class WatermarkMediaType(StrEnum):
    audio = 'audio'
    image = 'image'
    video = 'video'
    text = 'text'

Enum where members are also (and must be) strings

Ancestors

enum.StrEnum
builtins.str
enum.ReprEnum
enum.Enum

Class variables

var audio
var image
var text
var video

class WeightRangeItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class WeightRangeItem(ScalarInt):
    __slots__ = ()
    _constraints = {'ge': 100, 'le': 900}

An int generated from a JSON Schema integer root.

Validates the way SchemaInt validates an integer field: strict, so "1" and True are refused, with a float carrying no fractional part narrowed to int because JSON Schema counts it as one.

Ancestors

adcp.types._scalar.ScalarInt
adcp.types._scalar._ScalarRoot
builtins.int