Module `adcp.types.domains.brand`

Types the AdCP brand schemas declare.

Importing from the domain says which variant you mean, where the flat adcp.types namespace can only bind one class per name:

from adcp.types.domains.brand import <Type>

A type this domain declares in more than one schema is not here: import it from its own schema's module, adcp.types.domains.brand.<schema>. Nothing here is renamed.

Auto-generated from the generated domain tree. DO NOT EDIT MANUALLY. Generation date: 2026-10-04 18:45:11 UTC

Sub-modules

adcp.types.domains.brand.acquire_rights_request
adcp.types.domains.brand.acquire_rights_response
adcp.types.domains.brand.creative_approval_request
adcp.types.domains.brand.creative_approval_response
adcp.types.domains.brand.get_brand_identity_request
adcp.types.domains.brand.get_brand_identity_response
adcp.types.domains.brand.get_rights_request
adcp.types.domains.brand.get_rights_response
adcp.types.domains.brand.revocation_notification
adcp.types.domains.brand.rights_pricing_option
adcp.types.domains.brand.rights_terms
adcp.types.domains.brand.search_brands_request
adcp.types.domains.brand.search_brands_response
adcp.types.domains.brand.update_rights_request
adcp.types.domains.brand.update_rights_response
adcp.types.domains.brand.verification_status
adcp.types.domains.brand.verify_brand_claim_request
adcp.types.domains.brand.verify_brand_claim_response
adcp.types.domains.brand.verify_brand_claims_request
adcp.types.domains.brand.verify_brand_claims_response

Classes

class AcquireRightsRequest (**data: Any)

Expand source code

class AcquireRightsRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    governance_context: Annotated[
        str | None,
        Field(
            description='Opaque intent authorization for this rights commitment. Required when governance applies to the resolved account.',
            max_length=4096,
            min_length=1,
            pattern='^[\\x20-\\x7E]+$',
        ),
    ] = None
    rights_id: Annotated[
        str, Field(description='Rights offering identifier from get_rights response')
    ]
    pricing_option_id: Annotated[
        str, Field(description='Selected pricing option from the rights offering')
    ]
    buyer: Annotated[brand_ref.BrandReference, Field(description="The buyer's brand identity")]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account context for this acquisition. Used by the brand agent to resolve any governance agent previously bound for this brand+operator pair via sync_governance. When both an inline governance_context token and a bound governance agent are present, the token is verified against that resolved relationship. An agent advertising adcp.governance_enforcement for acquire_rights MUST resolve an account and returns ACCOUNT_REQUIRED when neither the request nor an existing resource supplies one; it MUST NOT infer that a missing token means ungoverned. Legacy non-claiming agents may continue to treat omission of both fields as ungoverned during 3.x. Pass a natural key (brand, operator, optional sandbox) or a seller-assigned account_id from list_accounts.'
        ),
    ] = None
    campaign: Annotated[Campaign, Field(description='Campaign details for rights clearance')]
    revocation_webhook: Annotated[
        push_notification_config_1.PushNotificationConfig,
        Field(
            description='Webhook for rights revocation notifications. If the rights holder needs to revoke rights (talent scandal, contract violation, etc.), they POST a revocation-notification to this URL. The buyer is responsible for stopping creative delivery upon receipt.'
        ),
    ]
    push_notification_config: Annotated[
        push_notification_config_1.PushNotificationConfig | None,
        Field(
            description='Webhook for async status updates if the acquisition requires approval. The rights agent sends a webhook notification when the status transitions to acquired or rejected.'
        ),
    ] = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated key for safe retries. Resubmitting with the same key returns the original response rather than creating a duplicate acquisition. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the boundary.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None
var buyer : BrandReference
var campaign : Campaign
var context : ContextObject | None
var ext : ExtensionObject | None
var governance_context : str | None
var idempotency_key : str
var model_config
var pricing_option_id : str
var push_notification_config : PushNotificationConfig | None
var revocation_webhook : PushNotificationConfig
var rights_id : str

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class AcquireRightsResponse1 (**data: Any)

Expand source code

class AcquireRightsResponse1(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    rights_id: str
    rights_status: Literal['acquired'] = 'acquired'
    brand_id: str
    terms: rights_terms_1.RightsTerms
    generation_credentials: list[generation_credential_1.GenerationCredential]
    restrictions: list[str] | None = None
    disclosure: Disclosure | None = None
    approval_webhook: push_notification_config_1.PushNotificationConfig | None = None
    usage_reporting_url: AnyUrl | None = None
    rights_constraint: Any
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var approval_webhook : PushNotificationConfig | None
var brand_id : str
var context : ContextObject | None
var disclosure : Disclosure | None
var ext : ExtensionObject | None
var generation_credentials : list[GenerationCredential]
var model_config
var restrictions : list[str] | None
var rights_constraint : Any
var rights_id : str
var rights_status : Literal['acquired']
var terms : RightsTerms
var usage_reporting_url : pydantic.networks.AnyUrl | None

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class AcquireRightsResponse2 (**data: Any)

Expand source code

class AcquireRightsResponse2(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    rights_id: str
    rights_status: Literal['pending_approval'] = 'pending_approval'
    brand_id: str
    detail: str | None = None
    estimated_response_time: str | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_id : str
var context : ContextObject | None
var detail : str | None
var estimated_response_time : str | None
var ext : ExtensionObject | None
var model_config
var rights_id : str
var rights_status : Literal['pending_approval']

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class AcquireRightsResponse3 (**data: Any)

Expand source code

class AcquireRightsResponse3(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    rights_id: str
    rights_status: Literal['rejected'] = 'rejected'
    brand_id: str
    reason: str
    suggestions: list[str] | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_id : str
var context : ContextObject | None
var ext : ExtensionObject | None
var model_config
var reason : str
var rights_id : str
var rights_status : Literal['rejected']
var suggestions : list[str] | None

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class AcquireRightsResponse4 (**data: Any)

Expand source code

class AcquireRightsResponse4(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Asset (**data: Any)

Expand source code

class Asset(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    asset_id: str
    asset_type: asset_content_type_1.AssetContentType
    url: AnyUrl
    tags: list[str] | None = None
    name: str | None = None
    description: str | None = None
    width: int | None = None
    height: int | None = None
    duration_seconds: float | None = None
    file_size_bytes: int | None = None
    format: str | None = 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var asset_id : str
var asset_type : AssetContentType
var description : str | None
var duration_seconds : float | None
var file_size_bytes : int | None
var format : str | None
var height : int | None
var model_config
var name : str | None
var tags : list[str] | None
var url : pydantic.networks.AnyUrl
var width : int | None

Inherited members

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

Expand source code

class Campaign(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    description: Annotated[str, Field(description='Description of how the rights will be used')]
    uses: Annotated[
        list[right_use.RightUse],
        Field(description='Specific rights uses for this campaign', min_length=1),
    ]
    countries: Annotated[
        list[Country] | None,
        Field(description='Countries where the campaign will run (ISO 3166-1 alpha-2)'),
    ] = None
    format_ids: Annotated[
        list[format_id.FormatReferenceStructuredObject] | None,
        Field(
            deprecated=True,
            description='Deprecated in AdCP 3.2; removed in AdCP 4.0. Legacy named formats that will be produced. Use `format_kinds` and optional `format_option_refs`.',
        ),
    ] = None
    format_kinds: Annotated[
        list[str] | None,
        Field(
            description='Canonical creative format kinds that will be produced under the rights grant.',
            min_length=1,
        ),
    ] = None
    format_option_refs: Annotated[
        list[format_option_ref.FormatOptionReference] | None,
        Field(
            description='Exact canonical publisher or product format options covered by the planned rights use, when kind alone is insufficient.',
            min_length=1,
        ),
    ] = None
    estimated_impressions: Annotated[
        SchemaInt | None,
        Field(
            description="Estimated total impressions for the campaign. Required when the brand agent will project commitment against a governance plan AND the selected pricing_option has model: 'cpm' — projection equals (pricing_option.price / 1000) × estimated_impressions evaluated in pricing_option.currency. The brand agent will project commitment whenever the request is governance-aware via either (a) an intent-phase governance_context token on the protocol envelope, or (b) `account` resolving to an account that has a governance agent previously bound via sync_governance. Brand agents MUST reject with INVALID_REQUEST (field: campaign.estimated_impressions) in either path when CPM-priced rights are requested and this field is omitted or zero; implementer-chosen defaults are non-conformant. See the acquire_rights task reference for the full validation contract including currency-mismatch handling.",
            ge=0,
        ),
    ] = None
    start_date: Annotated[date | None, Field(description='Campaign start date (ISO 8601)')] = None
    end_date: Annotated[
        date | None,
        Field(
            description='Campaign end date (ISO 8601). Brand agents MUST reject with INVALID_REQUEST (field: campaign.end_date) when end_date is in the past at the time of the request — acquiring rights for an elapsed window produces a zero-duration grant and is almost always a buyer-side bug.'
        ),
    ] = 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 description : str
var end_date : datetime.date | None
var estimated_impressions : int | None
var format_ids : list[FormatReferenceStructuredObject] | None
var format_kinds : list[str] | None
var format_option_refs : list[FormatOptionReference1 | FormatOptionReference2] | None
var model_config
var start_date : datetime.date | None
var uses : list[RightUse]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Claim (**data: Any)

Expand source code

class Claim(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    subsidiary_domain: Annotated[
        str,
        Field(
            description='Domain of the leaf brand whose `house_domain` claim is being verified.',
            pattern='^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]{0,61}[A-Za-z0-9])$',
        ),
    ]
    subsidiary_brand_id: Annotated[
        str | None,
        Field(
            description='Stable brand identifier the leaf uses for itself. Optional but recommended.',
            pattern='^[a-z0-9_]+$',
        ),
    ] = None
    observed_at: Annotated[
        AwareDatetime | None, Field(description="When the caller observed the leaf's claim.")
    ] = 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 observed_at : pydantic.types.AwareDatetime | None
var subsidiary_brand_id : str | None
var subsidiary_domain : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Claim1 (**data: Any)

Expand source code

class Claim1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    parent_domain: Annotated[
        str,
        Field(
            description="Domain of the house claimed as this brand's parent.",
            pattern='^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]{0,61}[A-Za-z0-9])$',
        ),
    ]
    claimant_says: Annotated[
        str | None, Field(description='Optional context — what the claimant published or said.')
    ] = None
    observed_at: 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 claimant_says : str | None
var model_config
var observed_at : pydantic.types.AwareDatetime | None
var parent_domain : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Claim2 (**data: Any)

Expand source code

class Claim2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    property: Annotated[Property, Field(description='Shape matches brand.json properties[] entry.')]
    use_case: Annotated[
        str | None, Field(description='Optional caller-declared use case.', max_length=100)
    ] = 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 property : Property
var use_case : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Claim3 (**data: Any)

Expand source code

class Claim3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    mark: Annotated[str, Field(max_length=200, min_length=1)]
    registry: Annotated[str | None, Field(max_length=50)] = None
    number: Annotated[str | None, Field(max_length=100)] = None
    countries: list[Country] | None = None
    use_case: Annotated[str | None, Field(max_length=100)] = 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 mark : str
var model_config
var number : str | None
var registry : str | None
var use_case : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ClaimEntry1 (**data: Any)

Expand source code

class ClaimEntry1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Literal['subsidiary'] = 'subsidiary'
    claim: Claim

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 claim : Claim
var claim_type : Literal['subsidiary']
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ClaimEntry2 (**data: Any)

Expand source code

class ClaimEntry2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Literal['parent'] = 'parent'
    claim: Claim1

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 claim : Claim1
var claim_type : Literal['parent']
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ClaimEntry3 (**data: Any)

Expand source code

class ClaimEntry3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Literal['property'] = 'property'
    claim: Claim2

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 claim : Claim2
var claim_type : Literal['property']
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ClaimEntry4 (**data: Any)

Expand source code

class ClaimEntry4(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Literal['trademark'] = 'trademark'
    claim: Claim3

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 claim : Claim3
var claim_type : Literal['trademark']
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Colors (**data: Any)

Expand source code

class Colors(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    primary: Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')] | Annotated[list[Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')]], Field(min_length=1)] | None = None
    secondary: Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')] | Annotated[list[Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')]], Field(min_length=1)] | None = None
    accent: Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')] | Annotated[list[Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')]], Field(min_length=1)] | None = None
    background: Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')] | Annotated[list[Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')]], Field(min_length=1)] | None = None
    text: Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')] | Annotated[list[Annotated[str, StringConstraints(pattern='^#[0-9A-Fa-f]{6}$')]], Field(min_length=1)] | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var accent : str | list[str] | None
var background : str | list[str] | None
var model_config
var primary : str | list[str] | None
var secondary : str | list[str] | None
var text : str | list[str] | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class CreativeApprovalRequest (**data: Any)

Expand source code

class CreativeApprovalRequest(AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    rights_id: Annotated[str, Field(description='Rights grant this creative was produced under')]
    creative_id: Annotated[
        str | None,
        Field(
            description='Buyer-assigned creative identifier. Equivalent to OpenRTB crid. Used to track approval status across resubmissions.'
        ),
    ] = None
    creative_url: Annotated[
        AnyUrl, Field(description='URL where the creative asset can be retrieved for review')
    ]
    creative_format: Annotated[
        format_id.FormatReferenceStructuredObject | None,
        Field(description='Format of the creative being submitted'),
    ] = None
    description: Annotated[
        str | None, Field(description='Description of the creative for reviewer context')
    ] = None
    metadata: Annotated[
        dict[str, Any] | None,
        Field(
            description='Additional creative metadata (duration, dimensions, target audience, etc.)'
        ),
    ] = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated key for safe retries. Resubmitting with the same key returns the original response. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var creative_format : FormatReferenceStructuredObject | None
var creative_id : str | None
var creative_url : pydantic.networks.AnyUrl
var description : str | None
var ext : ExtensionObject | None
var idempotency_key : str
var metadata : dict[str, typing.Any] | None
var model_config
var rights_id : str

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class CreativeApprovalResponse1 (**data: Any)

Expand source code

class CreativeApprovalResponse1(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    approval_status: Annotated[
        Literal['approved'],
        Field(
            description='Creative has been approved for distribution. Renamed from `status` in 3.1 to free the top-level `status` key for the envelope task-status (TaskStatus) under MCP flat-on-the-wire serialization (#4878).'
        ),
    ] = 'approved'
    rights_id: str
    creative_id: Annotated[
        str | None, Field(description="Echo of the buyer's creative identifier")
    ] = None
    creative_url: AnyUrl | None = None
    approved_at: AwareDatetime | None = None
    conditions: Annotated[
        list[str] | None,
        Field(description="Conditions on the approval (e.g., 'approved for NL market only')"),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

Class variables

var approval_status : Literal['approved']
var approved_at : pydantic.types.AwareDatetime | None
var conditions : list[str] | None
var context : ContextObject | None
var creative_id : str | None
var creative_url : pydantic.networks.AnyUrl | None
var ext : ExtensionObject | None
var model_config
var rights_id : str

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class CreativeApprovalResponse2 (**data: Any)

Expand source code

class CreativeApprovalResponse2(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    approval_status: Annotated[Literal['rejected'], Field(description='Creative was rejected')] = 'rejected'
    rights_id: str
    creative_id: Annotated[
        str | None, Field(description="Echo of the buyer's creative identifier")
    ] = None
    creative_url: AnyUrl | None = None
    reason: Annotated[str, Field(description='Why the creative was rejected')]
    suggestions: Annotated[
        list[str] | None,
        Field(
            description='Actionable feedback for revision. If present, the buyer can revise and resubmit the creative. If absent, the rejection is final for this creative concept.'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

Class variables

var approval_status : Literal['rejected']
var context : ContextObject | None
var creative_id : str | None
var creative_url : pydantic.networks.AnyUrl | None
var ext : ExtensionObject | None
var model_config
var reason : str
var rights_id : str
var suggestions : list[str] | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class CreativeApprovalResponse3 (**data: Any)

Expand source code

class CreativeApprovalResponse3(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    approval_status: Annotated[
        Literal['pending_review'], Field(description='Creative is queued for review')
    ] = 'pending_review'
    rights_id: str
    creative_id: Annotated[
        str | None, Field(description="Echo of the buyer's creative identifier")
    ] = None
    creative_url: AnyUrl | None = None
    estimated_response_time: Annotated[
        str | None, Field(description="Expected time for review (e.g., '24h', '2 business days')")
    ] = None
    status_url: Annotated[
        AnyUrl | None,
        Field(
            description='URL to poll for updated approval status. GET this URL to receive a creative-approval-response. Poll at reasonable intervals (suggested: every 5 minutes, back off after 1 hour to every 30 minutes). Stop polling after estimated_response_time has elapsed and the approval_status is still pending_review.'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

Class variables

var approval_status : Literal['pending_review']
var context : ContextObject | None
var creative_id : str | None
var creative_url : pydantic.networks.AnyUrl | None
var estimated_response_time : str | None
var ext : ExtensionObject | None
var model_config
var rights_id : str
var status_url : pydantic.networks.AnyUrl | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class CreativeApprovalResponse4 (**data: Any)

Expand source code

class CreativeApprovalResponse4(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    errors: Annotated[list[error.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Disclosure (**data: Any)

Expand source code

class Disclosure(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    required: bool
    text: 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var required : bool
var text : str | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Excluded (**data: Any)

Expand source code

class Excluded(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    brand_id: str
    name: str | None = None
    reason: str
    suggestions: 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_id : str
var model_config
var name : str | None
var reason : str
var suggestions : list[str] | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

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

Expand source code

class ExcludedCountry(Country):
    pass

A str generated from a JSON Schema string root.

Ancestors

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

class Exclusivity (**data: Any)

Expand source code

class Exclusivity(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    scope: str | None = None
    countries: list[Country] | 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 countries : list[Country] | None
var model_config
var scope : str | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ExclusivityStatus (**data: Any)

Expand source code

class ExclusivityStatus(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    available: bool | None = None
    existing_exclusives: 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var available : bool | None
var existing_exclusives : list[str] | None
var model_config

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Field1 (*args, **kwds)

Expand source code

class Field1(StrEnum):
    description = 'description'
    industries = 'industries'
    keller_type = 'keller_type'
    logos = 'logos'
    colors = 'colors'
    fonts = 'fonts'
    visual_guidelines = 'visual_guidelines'
    tone = 'tone'
    tagline = 'tagline'
    voice_synthesis = 'voice_synthesis'
    assets = 'assets'
    rights = 'rights'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var assets
var colors
var description
var fonts
var industries
var keller_type
var logos
var rights
var tagline
var tone
var visual_guidelines
var voice_synthesis

class File (**data: Any)

Expand source code

class File(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    url: Annotated[str, StringConstraints(pattern='^https://')]
    weight: Annotated[int, Field(ge=100, le=900)] | None = None
    weight_range: Annotated[list[Annotated[int, Field(ge=100, le=900)]], Field(min_length=2, max_length=2)] | None = None
    style: Literal['normal', 'italic', 'oblique'] | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var style : Literal['normal', 'italic', 'oblique'] | None
var url : str
var weight : int | None
var weight_range : list[int] | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class FontRole2 (**data: Any)

Expand source code

class FontRole2(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    family: str
    files: Annotated[list[File], Field(max_length=36)] | None = None
    opentype_features: Annotated[list[Annotated[str, StringConstraints(pattern='^[a-z0-9]{4}$')]], Field(max_length=20)] | None = None
    fallbacks: Annotated[list[Annotated[str, StringConstraints(max_length=100)]], Field(max_length=10)] | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var fallbacks : list[str] | None
var family : str
var files : list[File] | None
var model_config
var opentype_features : list[str] | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Fonts (**data: Any)

Expand source code

class Fonts(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    primary: str | FontRole2 | None = None
    secondary: str | FontRole2 | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var primary : str | FontRole2 | None
var secondary : str | FontRole2 | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetBrandIdentityRequest (**data: Any)

Expand source code

class GetBrandIdentityRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    brand_id: Annotated[str, Field(description='Brand identifier from brand.json brands array')]
    fields: Annotated[
        list[Field1] | None,
        Field(
            description='Optional identity sections to include in the response. When omitted, all sections the caller is authorized to see are returned. Core fields (brand_id, house, names) are always returned and do not need to be requested.',
            min_length=1,
        ),
    ] = None
    use_case: Annotated[
        str | None,
        Field(
            description="Intended use case, so the agent can tailor the response. A 'voice_synthesis' use case returns voice configs; a 'likeness' use case returns high-res photos and appearance guidelines."
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_id : str
var context : ContextObject | None
var ext : ExtensionObject | None
var fields : list[Field1] | None
var model_config
var use_case : str | None

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetBrandIdentityResponse1 (**data: Any)

Expand source code

class GetBrandIdentityResponse1(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    brand_id: str
    house: House
    names: list[dict[str, str]]
    description: str | None = None
    industries: Annotated[list[str], Field(min_length=1)] | None = None
    keller_type: Literal['master', 'sub_brand', 'endorsed', 'independent'] | None = None
    logos: list[Logo] | None = None
    colors: Colors | None = None
    fonts: Fonts | None = None
    visual_guidelines: dict[str, Any] | None = None
    tone: Tone | None = None
    tagline: str | Annotated[list[dict[str, Annotated[str, StringConstraints(min_length=1)]]], Field(min_length=1)] | None = None
    voice_synthesis: VoiceSynthesis | None = None
    assets: list[Asset] | None = None
    rights: Rights | None = None
    available_fields: list[Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var assets : list[Asset] | None
var available_fields : list[typing.Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None
var brand_id : str
var colors : Colors | None
var context : ContextObject | None
var description : str | None
var ext : ExtensionObject | None
var fonts : Fonts | None
var house : House
var industries : list[str] | None
var keller_type : Literal['master', 'sub_brand', 'endorsed', 'independent'] | None
var logos : list[Logo] | None
var model_config
var names : list[dict[str, str]]
var rights : Rights | None
var tagline : str | list[dict[str, str]] | None
var tone : Tone | None
var visual_guidelines : dict[str, typing.Any] | None
var voice_synthesis : VoiceSynthesis | None

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetBrandIdentityResponse2 (**data: Any)

Expand source code

class GetBrandIdentityResponse2(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetRightsRequest (**data: Any)

Expand source code

class GetRightsRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    query: Annotated[
        str,
        Field(
            description='Natural language description of desired rights. The agent interprets intent, budget signals, and compatibility from this text.',
            max_length=2000,
        ),
    ]
    uses: Annotated[
        list[right_use.RightUse],
        Field(
            description='Rights uses being requested. The agent returns options covering these uses, potentially bundled into composite pricing.',
            min_length=1,
        ),
    ]
    buyer_brand: Annotated[
        brand_ref.BrandReference | None,
        Field(
            description="The buyer's brand. The agent fetches the buyer's brand.json for compatibility filtering (e.g., dietary conflicts, competitor exclusions)."
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Countries where rights are needed (ISO 3166-1 alpha-2). Filters to rights available in these markets.'
        ),
    ] = None
    brand_id: Annotated[
        str | None,
        Field(
            description="Search within a specific brand's rights. If omitted, searches across the agent's full roster."
        ),
    ] = None
    right_type: Annotated[
        right_type_1.RightType | None,
        Field(description='Filter by type of rights (talent, music, stock_media, etc.)'),
    ] = None
    include_excluded: Annotated[
        StrictBool | None,
        Field(
            description='Include filtered-out results in the excluded array with reasons. Defaults to false.'
        ),
    ] = False
    pagination: Annotated[
        pagination_request.PaginationRequest | None,
        Field(description='Pagination parameters for large result sets'),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var brand_id : str | None
var buyer_brand : BrandReference | None
var context : ContextObject | None
var countries : list[Country] | None
var ext : ExtensionObject | None
var include_excluded : bool | None
var model_config
var pagination : PaginationRequest | None
var query : str
var right_type : RightType | None
var uses : list[RightUse]

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetRightsResponse1 (**data: Any)

Expand source code

class GetRightsResponse1(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    rights: list[Right]
    excluded: list[Excluded] | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var excluded : list[Excluded] | None
var ext : ExtensionObject | None
var model_config
var rights : list[Right]

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class GetRightsResponse2 (**data: Any)

Expand source code

class GetRightsResponse2(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- 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 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 PreviewAsset (**data: Any)

Expand source code

class PreviewAsset(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    url: AnyUrl
    usage: 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var url : pydantic.networks.AnyUrl
var usage : str | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Property (**data: Any)

Expand source code

class Property(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    type: property_type.PropertyType
    identifier: str
    store: Store | None = None
    region: 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 identifier : str
var model_config
var region : str | None
var store : Store | None
var type : PropertyType

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RelationshipTrust (*args, **kwds)

Expand source code

class RelationshipTrust(StrEnum):
    inline = 'inline'
    mutual = 'mutual'
    leaf_only = 'leaf_only'
    house_only = 'house_only'
    standalone = 'standalone'
    unverifiable = 'unverifiable'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var house_only
var inline
var leaf_only
var mutual
var standalone
var unverifiable

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

Expand source code

class ResultEntry(RootModel[ResultEntry1 | ResultEntry2]):
    root: Annotated[
        ResultEntry1 | ResultEntry2,
        Field(
            description='One entry in `results[]`. Either a per-claim success (claim_type + status + optional details/context_note) or a per-claim error (error field only). Mirrors the single-target `verify_brand_claim` response success arm shape.'
        ),
    ]

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

Class variables

var model_config
var root : ResultEntry1 | ResultEntry2

class ResultEntry1 (**data: Any)

Expand source code

class ResultEntry1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Annotated[
        ClaimType,
        Field(description="Echoes the request item's claim_type for caller-side routing."),
    ]
    status: Annotated[
        verification_status.VerificationStatus,
        Field(
            description='Verification status for this claim. Not every status applies to every claim_type - see the single-target task page for the applicable subset.'
        ),
    ]
    details: Annotated[
        dict[str, Any] | None,
        Field(
            description="Per-claim-type response fields. Shape varies - see the single-target task page for each claim_type's expected fields."
        ),
    ] = None
    context_note: Annotated[
        str | None,
        Field(description='Public - free-text context the brand chooses to surface.', max_length=500),
    ] = 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 claim_type : ClaimType
var context_note : str | None
var details : dict[str, typing.Any] | None
var model_config
var status : VerificationStatus

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class ResultEntry2 (**data: Any)

Expand source code

class ResultEntry2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    error: error_1.Error

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 error : Error
var model_config

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RevocationNotification (**data: Any)

Expand source code

class RevocationNotification(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    idempotency_key: Annotated[
        str,
        Field(
            description='Sender-generated key stable across retries of the same revocation notification. Rights holders MUST generate a cryptographically random value (UUID v4 recommended) per distinct revocation event and reuse the same key when retrying delivery. Buyers MUST dedupe by this key, scoped to the authenticated sender identity (HMAC secret or Bearer credential); keys from different senders are independent.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    rights_id: Annotated[str, Field(description='The revoked rights grant identifier')]
    brand_id: Annotated[str, Field(description='Brand identifier of the rights subject')]
    reason: Annotated[str, Field(description='Human-readable reason for revocation')]
    effective_at: Annotated[
        AwareDatetime,
        Field(
            description='When the revocation takes effect. Immediate revocations use current time. Grace periods use a future time. The buyer must stop serving creative using these rights by this time.'
        ),
    ]
    revoked_uses: Annotated[
        list[right_use.RightUse] | None,
        Field(
            description='If present, only these uses are revoked (partial revocation). If absent, all uses under the grant are revoked.',
            min_length=1,
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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 brand_id : str
var context : ContextObject | None
var effective_at : pydantic.types.AwareDatetime
var ext : ExtensionObject | None
var idempotency_key : str
var model_config
var reason : str
var revoked_uses : list[RightUse] | None
var rights_id : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class Right (**data: Any)

Expand source code

class Right(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    rights_id: str
    brand_id: str
    name: str
    description: str | None = None
    right_type: right_type_1.RightType | None = None
    match_score: Annotated[float, Field(ge=0, le=1)] | None = None
    match_reasons: list[str] | None = None
    available_uses: list[right_use_1.RightUse]
    countries: list[Annotated[str, StringConstraints(pattern='^[A-Z]{2}$')]] | None = None
    excluded_countries: list[Annotated[str, StringConstraints(pattern='^[A-Z]{2}$')]] | None = None
    exclusivity_status: ExclusivityStatus | None = None
    pricing_options: Annotated[list[rights_pricing_option_1.RightsPricingOption], Field(min_length=1)]
    content_restrictions: list[str] | None = None
    preview_assets: list[PreviewAsset] | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var available_uses : list[RightUse]
var brand_id : str
var content_restrictions : list[str] | None
var countries : list[str] | None
var description : str | None
var excluded_countries : list[str] | None
var exclusivity_status : ExclusivityStatus | None
var match_reasons : list[str] | None
var match_score : float | None
var model_config
var name : str
var preview_assets : list[PreviewAsset] | None
var pricing_options : list[RightsPricingOption]
var right_type : RightType | None
var rights_id : str

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class RightsPricingOption (**data: Any)

Expand source code

class RightsPricingOption(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    pricing_option_id: Annotated[
        str,
        Field(
            description='Unique identifier for this pricing option. Referenced in acquire_rights and report_usage.'
        ),
    ]
    model: Annotated[
        pricing_model.PricingModel, Field(description='Pricing model (cpm, flat_rate, etc.)')
    ]
    price: Annotated[
        StrictFloat,
        Field(
            description='Price amount. Interpretation depends on model: CPM = cost per 1,000 impressions, flat_rate = fixed cost per period.',
            ge=0.0,
        ),
    ]
    currency: Annotated[str, Field(description='ISO 4217 currency code', pattern='^[A-Z]{3}$')]
    uses: Annotated[
        list[right_use.RightUse],
        Field(
            description='Which rights uses this pricing option covers. A single option can bundle multiple uses (e.g., likeness + voice).',
            min_length=1,
        ),
    ]
    period: Annotated[
        rights_billing_period.RightsBillingPeriod | None,
        Field(description='Billing period for flat_rate and time-based models'),
    ] = None
    impression_cap: Annotated[
        SchemaInt | None,
        Field(description='Maximum impressions included in this pricing option per period', ge=1),
    ] = None
    overage_cpm: Annotated[
        StrictFloat | None,
        Field(description='CPM rate applied to impressions exceeding the impression_cap', ge=0.0),
    ] = None
    description: Annotated[
        str | None, Field(description='Human-readable description of this pricing option')
    ] = None
    ext: ext_1.ExtensionObject | 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 currency : str
var description : str | None
var ext : ExtensionObject | None
var impression_cap : int | None
var model : PricingModel
var model_config
var overage_cpm : float | None
var period : RightsBillingPeriod | None
var price : float
var pricing_option_id : str
var uses : list[RightUse]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class RightsTerms (**data: Any)

Expand source code

class RightsTerms(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    pricing_option_id: str
    amount: Annotated[StrictFloat, Field(ge=0.0)]
    currency: Annotated[str, Field(pattern='^[A-Z]{3}$')]
    period: rights_billing_period.RightsBillingPeriod | None = None
    uses: list[right_use.RightUse]
    impression_cap: Annotated[SchemaInt | None, Field(ge=1)] = None
    overage_cpm: Annotated[StrictFloat | None, Field(ge=0.0)] = None
    start_date: date | None = None
    end_date: date | None = None
    exclusivity: Annotated[
        Exclusivity | None, Field(description='Exclusivity terms if applicable')
    ] = 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 amount : float
var currency : str
var end_date : datetime.date | None
var exclusivity : Exclusivity | None
var impression_cap : int | None
var model_config
var overage_cpm : float | None
var period : RightsBillingPeriod | None
var pricing_option_id : str
var start_date : datetime.date | None
var uses : list[RightUse]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SearchBrandResult (**data: Any)

Expand source code

class SearchBrandResult(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    brand_id: Annotated[
        str,
        Field(
            description='Brand identifier. Pass to get_brand_identity or get_rights for the next step.'
        ),
    ]
    house: Annotated[
        House | None,
        Field(
            description='The house (corporate entity) associated with this brand. Present when a house affiliation is on record. Use relationship_trust to determine whether this association has been reciprocally confirmed by the house.'
        ),
    ] = None
    relationship_trust: Annotated[
        RelationshipTrust | None,
        Field(
            description="Trust verdict for the brand-to-house relationship, computed from the mutual-assertion model. inline = brand defined inside the house's own document; mutual = both sides publish the relationship (trust-extending); leaf_only = brand claims house but house has not reciprocated or declaration is expired; house_only = house claims brand, brand has not reciprocated; standalone = brand claims no house; unverifiable = claimed house could not be checked. When absent, trust has not yet been computed — absent MUST NOT be interpreted as standalone. Use get_brand_identity or verify_brand_claim for authoritative trust resolution."
        ),
    ] = None
    relationship_verified_at: Annotated[
        AwareDatetime | None,
        Field(
            description='When the mutual-assertion edge was last confirmed by both sides. Present only when relationship_trust is mutual.'
        ),
    ] = None
    claimed_house_domain: Annotated[
        str | None,
        Field(
            description='Canonical domain of the house this brand self-declares as its parent. Not trust-extending on its own. Present for leaf_only and unverifiable trust states where the brand has made a claim that could not be or has not been reciprocated.'
        ),
    ] = None
    names: Annotated[
        list[dict[str, str]],
        Field(
            description="Localized brand names with BCP 47 locale code keys (e.g., 'en_US', 'fr_CA')."
        ),
    ]
    description: Annotated[str | None, Field(description='Brand description')] = None
    industries: Annotated[
        list[advertiser_industry.AdvertiserIndustry] | None,
        Field(
            description='Brand industries, following the advertiser-industry taxonomy', min_length=1
        ),
    ] = None
    keller_type: Annotated[
        KellerType | None,
        Field(
            description='Brand architecture type: master (primary brand of house), sub_brand (carries parent name), endorsed (independent identity backed by parent), independent (operates separately)'
        ),
    ] = None
    logos: Annotated[
        list[Logo] | None,
        Field(
            description='Standard-resolution logos for display during discovery. High-res variants are gated behind get_brand_identity with account authorization.'
        ),
    ] = None
    rights: Annotated[
        Rights | None,
        Field(
            description='Rights availability summary. Signals whether this brand has licensable rights and in which markets. For detailed pricing and rights records, use get_rights.'
        ),
    ] = 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 : str
var claimed_house_domain : str | None
var description : str | None
var house : House | None
var industries : list[AdvertiserIndustry] | None
var keller_type : KellerType | None
var logos : list[Logo] | None
var model_config
var names : list[dict[str, str]]
var relationship_trust : RelationshipTrust | None
var relationship_verified_at : pydantic.types.AwareDatetime | None
var rights : Rights | None

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class SearchBrandsRequest (**data: Any)

Expand source code

class SearchBrandsRequest(AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    query: Annotated[
        str,
        Field(
            description='Natural language description of the brands to find. The agent interprets intent, category, and roster coverage from this text.',
            max_length=2000,
        ),
    ]
    industries: Annotated[
        list[advertiser_industry.AdvertiserIndustry] | None,
        Field(
            description='Optional industry filter. The agent restricts results to brands operating in these industries. Values follow the advertiser-industry taxonomy; the agent SHOULD accept unknown values gracefully per the advertiser-industry extension policy.',
            min_length=1,
        ),
    ] = None
    countries: Annotated[
        list[Country] | None,
        Field(
            description='Optional market filter. Returns brands with rights availability in at least one of the specified countries (ISO 3166-1 alpha-2).',
            min_length=1,
        ),
    ] = None
    buyer_brand: Annotated[
        brand_ref.BrandReference | None,
        Field(
            description="The buyer's brand. When provided, the agent SHOULD apply the same compatibility filtering as get_rights — filtering out brands with category conflicts, competitor exclusions, or dietary restrictions that would prevent licensing. When omitted, results are returned without compatibility filtering."
        ),
    ] = None
    pagination: Annotated[
        pagination_request.PaginationRequest | None,
        Field(description='Pagination parameters for large result sets'),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var buyer_brand : BrandReference | None
var context : ContextObject | None
var countries : list[Country] | None
var ext : ExtensionObject | None
var industries : list[AdvertiserIndustry] | None
var model_config
var pagination : PaginationRequest | None
var query : str

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class SearchBrandsResponse (**data: Any)

Expand source code

class SearchBrandsResponse(AdcpVersionEnvelope, ProtocolEnvelope):
    brands: Annotated[
        list[SearchBrandResult] | None,
        Field(description='Brand stubs matching the query, ranked by relevance'),
    ] = None
    pagination: Annotated[
        pagination_response.PaginationResponse | None,
        Field(
            description='Pagination metadata. Present when has_more is true or total_count is known.'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    errors: Annotated[list[error.Error] | None, Field(min_length=1)] = None

    @model_validator(mode='after')
    def _require_schema_required_group(self) -> SearchBrandsResponse:
        # ``required`` asks whether the caller supplied the field, which is what
        # model_fields_set answers. An explicit null is a supplied value — on a
        # mutation input it is the command to clear — and a default the caller
        # never sent is not.
        for group in (('brands',), ('errors',),):
            if all(name in self.model_fields_set for name in group):
                return self
        raise ValueError(
            'SearchBrandsResponse requires at least one of these field groups: brands | errors'
        )

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

Class variables

var brands : list[SearchBrandResult] | None
var context : ContextObject | None
var errors : list[Error] | None
var ext : ExtensionObject | None
var model_config
var pagination : PaginationResponse | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class Store (*args, **kwds)

Expand source code

class Store(StrEnum):
    apple = 'apple'
    google = 'google'
    amazon = 'amazon'
    roku = 'roku'
    fire_tv = 'fire_tv'
    samsung = 'samsung'
    lg = 'lg'
    vizio = 'vizio'
    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 fire_tv
var google
var lg
var other
var roku
var samsung
var vizio

class Tone (**data: Any)

Expand source code

class Tone(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    voice: str | None = None
    attributes: list[str] | None = None
    dos: list[str] | None = None
    donts: 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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var attributes : list[str] | None
var donts : list[str] | None
var dos : list[str] | None
var model_config
var voice : str | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class UpdateRightsRequest (**data: Any)

Expand source code

class UpdateRightsRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    governance_context: Annotated[
        str | None,
        Field(
            description='Opaque intent authorization for a commitment-increasing rights update.',
            max_length=4096,
            min_length=1,
            pattern='^[\\x20-\\x7E]+$',
        ),
    ] = None
    rights_id: Annotated[
        str, Field(description='Rights grant identifier from acquire_rights response')
    ]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account context for this update. Used by the brand agent to resolve any governance agent previously bound for this brand+operator pair via sync_governance — update_rights is a modification-phase governance trigger (per `/docs/governance/campaign/specification#spend-commit-invocation`) and the brand agent consults the bound agent when computing the incremental commit delta. When both an inline governance_context token (on the protocol envelope) and a bound governance agent are present, the inline token wins. Pass a natural key (brand, operator, optional sandbox) or a seller-assigned account_id from list_accounts. The estimated_impressions / commit-delta projection rule for governance-aware updates is tracked separately and not yet normative on this task.'
        ),
    ] = None
    end_date: Annotated[
        date | None,
        Field(
            description='New end date for the rights grant (must be >= current end_date). Extending the grant may re-issue generation credentials with updated expiration.'
        ),
    ] = None
    impression_cap: Annotated[
        SchemaInt | None,
        Field(
            description='New impression cap for the grant. Must be >= impressions already delivered.',
            ge=1,
        ),
    ] = None
    pricing_option_id: Annotated[
        str | None,
        Field(
            description="Switch to a different pricing option from the original get_rights offering. The new option must be compatible with the existing grant's uses and countries."
        ),
    ] = None
    paused: Annotated[
        StrictBool | None,
        Field(
            description='Pause or resume the rights grant. When paused, generation credentials are suspended and creative delivery should stop. When resumed, credentials are re-activated.'
        ),
    ] = None
    push_notification_config: Annotated[
        push_notification_config_1.PushNotificationConfig | None,
        Field(description='Webhook for async update notifications if the update requires approval'),
    ] = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated idempotency key for safe retries. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None
var context : ContextObject | None
var end_date : datetime.date | None
var ext : ExtensionObject | None
var governance_context : str | None
var idempotency_key : str
var impression_cap : int | None
var model_config
var paused : bool | None
var pricing_option_id : str | None
var push_notification_config : PushNotificationConfig | None
var rights_id : str

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class UpdateRightsResponse1 (**data: Any)

Expand source code

class UpdateRightsResponse1(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    rights_id: str
    terms: rights_terms_1.RightsTerms
    generation_credentials: list[generation_credential_1.GenerationCredential] = Field(
        default_factory=list
    )
    rights_constraint: Any | None = None
    paused: bool | None = None
    implementation_date: AwareDatetime | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var ext : ExtensionObject | None
var generation_credentials : list[GenerationCredential]
var implementation_date : pydantic.types.AwareDatetime | None
var model_config
var paused : bool | None
var rights_constraint : typing.Any | None
var rights_id : str
var terms : RightsTerms

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class UpdateRightsResponse2 (**data: Any)

Expand source code

class UpdateRightsResponse2(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(extra='allow')
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- 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 VerificationStatus (*args, **kwds)

Expand source code

class VerificationStatus(StrEnum):
    owned = 'owned'
    pending_review = 'pending_review'
    transferring = 'transferring'
    disputed = 'disputed'
    not_ours = 'not_ours'
    archived = 'archived'
    licensed_in = 'licensed_in'
    licensed_out = 'licensed_out'
    unknown = 'unknown'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var archived
var disputed
var licensed_in
var licensed_out
var not_ours
var owned
var pending_review
var transferring
var unknown

class VerifyBrandClaimErrorResponse (**data: Any)

Expand source code

class VerifyBrandClaimErrorResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimPayload (**data: Any)

Expand source code

class VerifyBrandClaimPayload(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    typ: Annotated[
        Literal['adcp-response-payload+jws'],
        Field(description='Type discriminator preventing cross-profile replay.'),
    ]
    task: Annotated[
        Literal['verify_brand_claim'],
        Field(description='Designated task whose response payload is signed.'),
    ]
    brand_domain: Annotated[
        str,
        Field(
            description='Brand tenant whose policy store produced the answer. The signer MUST derive this from server-side tenant resolution, not caller-supplied request fields.',
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ]
    agent_url: Annotated[
        AnyUrl,
        Field(
            description='Canonical URL of the responding brand agent entry whose response-signing key verifies this envelope.'
        ),
    ]
    request_hash: Annotated[
        str,
        Field(
            description='sha256: prefix plus unpadded base64url SHA-256 of the canonical request-binding object for this call.',
            pattern='^sha256:[A-Za-z0-9_-]{43}$',
        ),
    ]
    iat: Annotated[int, Field(description='Issued-at time as Unix epoch seconds.', ge=0)]
    exp: Annotated[
        int,
        Field(
            description='Expiration time as Unix epoch seconds. Online verifiers reject envelopes after this time, allowing only implementation-defined clock skew.',
            ge=0,
        ),
    ]
    response: VerifyBrandClaimSignedSuccessPayload

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 brand_domain : str
var exp : int
var iat : int
var model_config
var request_hash : str
var response : VerifyBrandClaimSignedSuccessPayload
var task : Literal['verify_brand_claim']
var typ : Literal['adcp-response-payload+jws']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimRequest (**data: Any)

Expand source code

class VerifyBrandClaimRequest(AdcpRequest, AdcpVersionEnvelope):
    claim_type: ClaimType
    claim: dict[str, Any]

    @model_validator(mode='after')
    def _require_schema_required_group(self) -> VerifyBrandClaimRequest:
        # ``required`` asks whether the caller supplied the field, which is what
        # model_fields_set answers. An explicit null is a supplied value — on a
        # mutation input it is the command to clear — and a default the caller
        # never sent is not.
        for group in (('claim_type', 'claim'),):
            if all(name in self.model_fields_set for name in group):
                return self
        raise ValueError(
            'VerifyBrandClaimRequest requires at least one of these field groups: claim_type+claim'
        )

The request message of a task in the pinned bundle's task registry.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var claim : dict[str, typing.Any]
var claim_type : ClaimType
var model_config

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimSignedResponse (**data: Any)

Expand source code

class VerifyBrandClaimSignedResponse(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    protected: Annotated[
        str,
        Field(
            description='Base64url-encoded JWS protected header. The decoded header MUST include alg, kid, and typ: adcp-response-payload+jws, and MUST NOT include the RFC 7797 b64 header. Verifiers enforce the key purpose by resolving kid to a JWK with adcp_use: response-signing.',
            pattern='^[A-Za-z0-9_-]+$',
        ),
    ]
    payload: Annotated[
        VerifyBrandClaimPayload,
        Field(
            description='Decoded signed payload. Signers compute the JWS payload bytes from the RFC 8785/JCS canonicalization of this object.'
        ),
    ]
    signature: Annotated[
        str,
        Field(
            description='Base64url-encoded JWS signature over the protected header and canonicalized payload.',
            pattern='^[A-Za-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 model_config
var payload : VerifyBrandClaimPayload
var protected : str
var signature : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimSignedSuccessPayload (**data: Any)

Expand source code

class VerifyBrandClaimSignedSuccessPayload(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: ClaimType
    verification_status: verification_status.VerificationStatus
    details: dict[str, Any] | None = None
    context_note: Annotated[str | None, Field(max_length=500)] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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 claim_type : ClaimType
var context : ContextObject | None
var context_note : str | None
var details : dict[str, typing.Any] | None
var ext : ExtensionObject | None
var model_config
var verification_status : VerificationStatus

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimSuccessResponse (**data: Any)

Expand source code

class VerifyBrandClaimSuccessResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    claim_type: Annotated[
        ClaimType,
        Field(description="Echoes the request's claim_type for caller-side routing."),
    ]
    verification_status: Annotated[
        verification_status.VerificationStatus,
        Field(
            description='Verification status. Not every status applies to every claim_type - see the task page for the applicable subset. Renamed from `status` in 3.1 to free the top-level `status` key for the envelope task-status (TaskStatus) under MCP flat-on-the-wire serialization (#4878).'
        ),
    ]
    signed_response: Annotated[
        VerifyBrandClaimSignedResponse,
        Field(
            description='Payload-envelope JWS attesting the canonical success response for verify_brand_claim. The signed payload response MUST match the unsigned task-body fields on this response, excluding signed_response and protocol/version envelope fields.'
        ),
    ]
    details: Annotated[
        dict[str, Any] | None,
        Field(
            description="Per-claim-type response fields. Shape varies - see the task page for each claim_type's expected fields."
        ),
    ] = None
    context_note: Annotated[
        str | None,
        Field(description='Public - free-text context the brand chooses to surface.', max_length=500),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var claim_type : ClaimType
var context : ContextObject | None
var context_note : str | None
var details : dict[str, typing.Any] | None
var ext : ExtensionObject | None
var model_config
var signed_response : VerifyBrandClaimSignedResponse
var verification_status : VerificationStatus

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsErrorResponse (**data: Any)

Expand source code

class VerifyBrandClaimsErrorResponse(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    errors: Annotated[list[error_1.Error], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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

Class variables

var context : ContextObject | None
var errors : list[Error]
var ext : ExtensionObject | None
var model_config

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsPayload (**data: Any)

Expand source code

class VerifyBrandClaimsPayload(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    typ: Annotated[
        Literal['adcp-response-payload+jws'],
        Field(description='Type discriminator preventing cross-profile replay.'),
    ]
    task: Annotated[
        Literal['verify_brand_claims'],
        Field(description='Designated task whose response payload is signed.'),
    ]
    brand_domain: Annotated[
        str,
        Field(
            description='Brand tenant whose policy store produced the answer. The signer MUST derive this from server-side tenant resolution, not caller-supplied request fields.',
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ]
    agent_url: Annotated[
        AnyUrl,
        Field(
            description='Canonical URL of the responding brand agent entry whose response-signing key verifies this envelope.'
        ),
    ]
    request_hash: Annotated[
        str,
        Field(
            description='sha256: prefix plus unpadded base64url SHA-256 of the canonical request-binding object for this call.',
            pattern='^sha256:[A-Za-z0-9_-]{43}$',
        ),
    ]
    iat: Annotated[int, Field(description='Issued-at time as Unix epoch seconds.', ge=0)]
    exp: Annotated[
        int,
        Field(
            description='Expiration time as Unix epoch seconds. Online verifiers reject envelopes after this time, allowing only implementation-defined clock skew.',
            ge=0,
        ),
    ]
    response: VerifyBrandClaimsSignedSuccessPayload

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 brand_domain : str
var exp : int
var iat : int
var model_config
var request_hash : str
var response : VerifyBrandClaimsSignedSuccessPayload
var task : Literal['verify_brand_claims']
var typ : Literal['adcp-response-payload+jws']

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsRequest (**data: Any)

Expand source code

class VerifyBrandClaimsRequest(VerifyBrandClaimsRequestBulk):
    pass

The request message of a task in the pinned bundle's task registry.

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

VerifyBrandClaimsRequestBulk
AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config

Inherited members

VerifyBrandClaimsRequestBulk:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsRequestBulk (**data: Any)

Expand source code

class VerifyBrandClaimsRequestBulk(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    claims: Annotated[
        list[ClaimEntry],
        Field(
            description='Ordered list of verification claims. The agent MUST return `results[]` in the same order (positional zip-by-index). Maximum batch size is 100 per call; agents MAY enforce a lower limit and SHOULD advertise it via `get_adcp_capabilities` (see the task page).',
            max_length=100,
            min_length=1,
        ),
    ]

The request message of a task in the pinned bundle's task registry.

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

AdcpRequest
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Subclasses

VerifyBrandClaimsRequest

Class variables

var claims : list[ClaimEntry1 | ClaimEntry2 | ClaimEntry3 | ClaimEntry4]
var model_config

Inherited members

AdcpRequest:
- get_account
- get_adcp_major_version
- get_adcp_version
- get_context
- get_idempotency_key
- get_push_notification_config
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsResponseBulk (**data: Any)

Expand source code

class VerifyBrandClaimsResponseBulk(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    results: Annotated[
        list[ResultEntry],
        Field(
            description="Per-claim results, positionally aligned with the request's claims.",
            min_length=1,
        ),
    ]
    signed_response: Annotated[
        VerifyBrandClaimsSignedResponse,
        Field(
            description='Payload-envelope JWS attesting the canonical bulk success response for verify_brand_claims. The signed payload response MUST match the unsigned task-body fields on this response, excluding signed_response and protocol/version envelope fields.'
        ),
    ]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

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

AdcpResponse
adcp.types.base._AdcpMessage
AdcpVersionEnvelope
ProtocolEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var context : ContextObject | None
var ext : ExtensionObject | None
var model_config
var results : list[ResultEntry]
var signed_response : VerifyBrandClaimsSignedResponse

Inherited members

AdcpResponse:
- get_adcp_error
- get_context
- get_message
- get_replayed
- get_status
- get_task_id
AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsSignedResponse (**data: Any)

Expand source code

class VerifyBrandClaimsSignedResponse(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    protected: Annotated[
        str,
        Field(
            description='Base64url-encoded JWS protected header. The decoded header MUST include alg, kid, and typ: adcp-response-payload+jws, and MUST NOT include the RFC 7797 b64 header. Verifiers enforce the key purpose by resolving kid to a JWK with adcp_use: response-signing.',
            pattern='^[A-Za-z0-9_-]+$',
        ),
    ]
    payload: Annotated[
        VerifyBrandClaimsPayload,
        Field(
            description='Decoded signed payload. Signers compute the JWS payload bytes from the RFC 8785/JCS canonicalization of this object.'
        ),
    ]
    signature: Annotated[
        str,
        Field(
            description='Base64url-encoded JWS signature over the protected header and canonicalized payload.',
            pattern='^[A-Za-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 model_config
var payload : VerifyBrandClaimsPayload
var protected : str
var signature : str

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VerifyBrandClaimsSignedSuccessPayload (**data: Any)

Expand source code

class VerifyBrandClaimsSignedSuccessPayload(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    results: Annotated[list[ResultEntry], Field(min_length=1)]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | 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 context : ContextObject | None
var ext : ExtensionObject | None
var model_config
var results : list[ResultEntry]

Inherited members

AdCPBaseModel:
- model_dump
- model_dump_json
- model_summary

class VoiceSynthesis (**data: Any)

Expand source code

class VoiceSynthesis(AdcpVersionEnvelope):
    model_config = ConfigDict(extra='allow')
    provider: str | None = None
    voice_id: str | None = None
    rights_offering_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

AdcpVersionEnvelope
AdCPBaseModel
pydantic.main.BaseModel

Class variables

var model_config
var provider : str | None
var rights_offering_id : str | None
var settings : dict[str, typing.Any] | None
var voice_id : str | None

Inherited members

AdcpVersionEnvelope:
- model_dump
- model_dump_json
- model_summary