Module adcp.types
AdCP Type System.
All AdCP types exported from a single location. Users should import from here or directly from adcp.
from adcp.types import Product, CreativeFilters
from adcp import Product, CreativeFilters
IMPORTANT: Never import directly from adcp.types.generated_poc or adcp.types._generated. These are internal modules regenerated from upstream schemas. Only import from adcp.types (this module) or adcp.
Type Coercion: Request types accept flexible input for developer ergonomics:
- Enum fields accept string values:
ListCreativeFormatsRequest(type="video") # Works!
- Context fields accept dicts:
GetProductsRequest(context={"key": "value"}) # Works!
- FieldModel lists accept strings:
ListCreativesRequest(fields=["creative_id", "name"]) # Works!
See adcp.types._ergonomic for implementation details.
Sub-modules
adcp.types.aliases-
Semantic type aliases for generated AdCP types …
adcp.types.baseadcp.types.coercion-
Type coercion utilities for improved type ergonomics …
adcp.types.core-
Core type definitions.
adcp.types.generated_pocadcp.types.registry-
Registry API types generated from OpenAPI spec …
Classes
class A2UiComponent (**data: Any)-
Expand source code
class A2UiComponent(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) component: Annotated[ dict[str, dict[str, Any]], Field(description='Component definition (keyed by component type)'), ] id: Annotated[str, Field(description='Unique identifier for this component within the surface')] parentId: Annotated[ str | None, Field(description='ID of the parent component (null for root)') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var component : dict[str, dict[str, typing.Any]]var id : strvar model_configvar parentId : str | None
Inherited members
class A2UiSurface (**data: Any)-
Expand source code
class A2UiSurface(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalogId: Annotated[ str | None, Field(description='Component catalog to use for rendering') ] = 'standard' components: Annotated[ list[component.A2UiComponent], Field(description='Flat list of components (adjacency list structure)'), ] dataModel: Annotated[ dict[str, Any] | None, Field(description='Application data that components can bind to') ] = None rootId: Annotated[ str | None, Field(description='ID of the root component (if not specified, first component is root)'), ] = None surfaceId: Annotated[str, Field(description='Unique identifier for this surface')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalogId : str | Nonevar components : list[A2UiComponent]var dataModel : dict[str, typing.Any] | Nonevar model_configvar rootId : str | Nonevar surfaceId : str
Inherited members
class Account (**data: Any)-
Expand source code
class Account(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) billing: Annotated[ Billing, Field( description='Who should be invoiced. operator: seller invoices the operator (agency or brand buying direct). agent: agent consolidates billing across brands. advertiser: seller invoices the advertiser directly, even when a different operator places orders on their behalf. The seller must either accept this billing model or reject the request.' ), ] billing_entity: Annotated[ business_entity.BusinessEntity | None, Field( description='Business entity details for the party responsible for payment. The agent provides this so the seller has the legal name, tax IDs, address, and bank details needed for formal B2B invoicing.' ), ] = None brand: Annotated[ brand_ref.BrandReference, Field( description="Brand reference identifying the advertiser. Uses the brand's house domain and optional brand_id from brand.json." ), ] operator: Annotated[ str, Field( description="Domain of the entity operating on the brand's behalf (e.g., 'pinnacle-media.com'). When the brand operates directly, this is the brand's domain. Verified against the brand's authorized_operators in brand.json.", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] payment_terms: Annotated[ PaymentTerms | None, Field( description='Payment terms for this account. The seller must either accept these terms or reject the account — terms are never silently remapped. When omitted, the seller applies its default terms.' ), ] = None sandbox: Annotated[ bool | None, Field( description='When true, provision this as a sandbox account with no real platform calls or billing. Only applicable to implicit accounts (require_operator_auth: false). For explicit accounts, sandbox accounts are pre-existing test accounts discovered via list_accounts.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var billing : Billingvar billing_entity : BusinessEntity | Nonevar brand : BrandReferencevar model_configvar operator : strvar payment_terms : PaymentTerms | Nonevar sandbox : bool | None
Inherited members
class AccountReference (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class AccountReference(RootModel[AccountReference1 | AccountReference2]): root: Annotated[ AccountReference1 | AccountReference2, Field( description='Reference to an account by seller-assigned ID or natural key. Use account_id for explicit accounts (require_operator_auth: true, discovered via list_accounts). Use the natural key (brand + operator) for implicit accounts (require_operator_auth: false, declared via sync_accounts). For sandbox: explicit accounts use account_id (pre-existing test account), implicit accounts use the natural key with sandbox: true.', examples=[ {'account_id': 'acc_acme_001'}, {'brand': {'domain': 'acme-corp.com'}, 'operator': 'acme-corp.com'}, { 'brand': {'brand_id': 'spark', 'domain': 'nova-brands.com'}, 'operator': 'pinnacle-media.com', }, { 'brand': {'domain': 'acme-corp.com'}, 'operator': 'acme-corp.com', 'sandbox': True, }, ], title='Account Reference', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[AccountReference1, AccountReference2]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : AccountReference1 | AccountReference2
class AccountReferenceById (**data: Any)-
Expand source code
class AccountReference1(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) account_id: Annotated[ str, Field( description='Seller-assigned account identifier (from sync_accounts or list_accounts)' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account_id : strvar model_config
Inherited members
class AccountReferenceByNaturalKey (**data: Any)-
Expand source code
class AccountReference2(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) brand: Annotated[ brand_ref.BrandReference, Field(description='Brand reference identifying the advertiser') ] operator: Annotated[ str, Field( description="Domain of the entity operating on the brand's behalf. When the brand operates directly, this is the brand's domain.", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] sandbox: Annotated[ bool | None, Field( description='When true, references the sandbox account for this brand/operator pair. Defaults to false (production account).' ), ] = FalseBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand : BrandReferencevar model_configvar operator : strvar sandbox : bool | None
Inherited members
class AccountScope (*args, **kwds)-
Expand source code
class AccountScope(Enum): operator = 'operator' brand = 'brand' operator_brand = 'operator_brand' agent = 'agent'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var agentvar brandvar operatorvar operator_brand
class AcquireRightsRequest (**data: Any)-
Expand source code
class AcquireRightsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) buyer: Annotated[brand_ref.BrandReference, Field(description="The buyer's brand identity")] campaign: Annotated[Campaign, Field(description='Campaign details for rights clearance')] context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, 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, ), ] = None pricing_option_id: Annotated[ str, Field(description='Selected pricing option from the rights offering') ] 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 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.' ), ] rights_id: Annotated[ str, Field(description='Rights offering identifier from get_rights response') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var buyer : BrandReferencevar campaign : Campaignvar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar pricing_option_id : strvar push_notification_config : PushNotificationConfig | Nonevar revocation_webhook : PushNotificationConfigvar rights_id : str
Inherited members
class AcquireRightsAcquiredResponse (**data: Any)-
Expand source code
class AcquireRightsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) approval_webhook: Annotated[ push_notification_config.PushNotificationConfig | None, Field( description='Authenticated webhook for submitting creatives for approval. POST a creative-approval-request to the URL using the provided authentication. The response is a creative-approval-response.' ), ] = None brand_id: Annotated[str, Field(description='Brand identifier of the rights subject')] context: context_1.ContextObject | None = None disclosure: Annotated[ Disclosure | None, Field(description='Required disclosure for creatives using these rights') ] = None ext: ext_1.ExtensionObject | None = None generation_credentials: Annotated[ list[generation_credential.GenerationCredential], Field(description='Scoped credentials for generating rights-cleared content'), ] restrictions: Annotated[ list[str] | None, Field(description='Usage restrictions and requirements') ] = None rights_constraint: Annotated[ rights_constraint_1.RightsConstraint, Field( description='Pre-built rights constraint for embedding in creative manifests. Populated from the agreed terms — the buyer does not need to construct it manually.' ), ] rights_id: Annotated[str, Field(description='Rights grant identifier')] status: Annotated[ Literal['acquired'], Field(description='Rights have been cleared and credentials issued') ] terms: Annotated[rights_terms.RightsTerms, Field(description='Agreed contractual terms')] usage_reporting_url: Annotated[ AnyUrl | None, Field(description='Endpoint for reporting usage against these rights') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var approval_webhook : PushNotificationConfig | Nonevar brand_id : strvar context : ContextObject | Nonevar disclosure : Disclosure | Nonevar ext : ExtensionObject | Nonevar generation_credentials : list[GenerationCredential]var model_configvar restrictions : list[str] | Nonevar rights_constraint : RightsConstraintvar rights_id : strvar status : Literal['acquired']var terms : RightsTermsvar usage_reporting_url : pydantic.networks.AnyUrl | None
Inherited members
class AcquireRightsPendingResponse (**data: Any)-
Expand source code
class AcquireRightsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand_id: str context: context_1.ContextObject | None = None detail: Annotated[str | None, Field(description='Explanation of what requires approval')] = None estimated_response_time: Annotated[ str | None, Field(description="Expected time for approval decision (e.g., '48h', '3 business days')"), ] = None ext: ext_1.ExtensionObject | None = None rights_id: str status: Annotated[ Literal['pending_approval'], Field(description='Rights require approval from the rights holder'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand_id : strvar context : ContextObject | Nonevar detail : str | Nonevar estimated_response_time : str | Nonevar ext : ExtensionObject | Nonevar model_configvar rights_id : strvar status : Literal['pending_approval']
Inherited members
class AcquireRightsRejectedResponse (**data: Any)-
Expand source code
class AcquireRightsResponse3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand_id: str context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None reason: Annotated[ str, Field( description="Why the rights request was rejected. May be sanitized to protect confidential brand rules — e.g., 'This violates our public figures brand guidelines' rather than naming the specific rule." ), ] rights_id: str status: Annotated[Literal['rejected'], Field(description='Rights request was rejected')] suggestions: Annotated[ list[str] | None, Field( description='Actionable alternatives the buyer can try. If present, the rejection is fixable — the buyer can adjust their request. If absent, the rejection is final for this talent/rights combination.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand_id : strvar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar reason : strvar rights_id : strvar status : Literal['rejected']var suggestions : list[str] | None
Inherited members
class AcquireRightsErrorResponse (**data: Any)-
Expand source code
class AcquireRightsResponse4(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[list[error.Error], Field(min_length=1)] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class ActivateSignalRequest (**data: Any)-
Expand source code
class ActivateSignalRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for this activation. Associates with a commercial relationship established via sync_accounts.' ), ] = None action: Annotated[ Action | None, Field( description="Whether to activate or deactivate the signal. Deactivating removes the segment from downstream platforms, required when campaigns end to comply with data governance policies (GDPR, CCPA). Defaults to 'activate' when omitted." ), ] = Action.activate context: context_1.ContextObject | None = None destinations: Annotated[ list[destination.Destination], Field( description='Target destination(s) for activation. If the authenticated caller matches one of these destinations, activation keys will be included in the response.', min_length=1, ), ] ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate activations on 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, ), ] = None pricing_option_id: Annotated[ str | None, Field( description="The pricing option selected from the signal's pricing_options in the get_signals response. Required when the signal has pricing options. Records the buyer's pricing commitment at activation time; pass this same value in report_usage for billing verification." ), ] = None signal_agent_segment_id: Annotated[ str, Field(description='The universal identifier for the signal to activate') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar action : Action | Nonevar context : ContextObject | Nonevar destinations : list[Destination]var ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar pricing_option_id : str | Nonevar signal_agent_segment_id : str
Inherited members
class ActivateSignalSuccessResponse (**data: Any)-
Expand source code
class ActivateSignalResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None deployments: Annotated[ list[deployment.Deployment], Field(description='Array of deployment results for each deployment target'), ] ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar deployments : list[Deployment]var ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class ActivateSignalErrorResponse (**data: Any)-
Expand source code
class ActivateSignalResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field( description='Array of errors explaining why activation failed (e.g., platform connectivity issues, signal definition problems, authentication failures)', min_length=1, ), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SegmentIdActivationKey (**data: Any)-
Expand source code
class ActivationKey1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) segment_id: Annotated[ str, Field(description='The platform-specific segment identifier to use in campaign targeting'), ] type: Annotated[Literal['segment_id'], Field(description='Segment ID based targeting')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar segment_id : strvar type : Literal['segment_id']
class PropertyIdActivationKey (**data: Any)-
Expand source code
class ActivationKey1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) segment_id: Annotated[ str, Field(description='The platform-specific segment identifier to use in campaign targeting'), ] type: Annotated[Literal['segment_id'], Field(description='Segment ID based targeting')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar segment_id : strvar type : Literal['segment_id']
Inherited members
class KeyValueActivationKey (**data: Any)-
Expand source code
class ActivationKey2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) key: Annotated[str, Field(description='The targeting parameter key')] type: Annotated[Literal['key_value'], Field(description='Key-value pair based targeting')] value: Annotated[str, Field(description='The targeting parameter value')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var key : strvar model_configvar type : Literal['key_value']var value : str
class PropertyTagActivationKey (**data: Any)-
Expand source code
class ActivationKey2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) key: Annotated[str, Field(description='The targeting parameter key')] type: Annotated[Literal['key_value'], Field(description='Key-value pair based targeting')] value: Annotated[str, Field(description='The targeting parameter value')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var key : strvar model_configvar type : Literal['key_value']var value : str
Inherited members
class AgentConfig (**data: Any)-
Expand source code
class AgentConfig(BaseModel): """Agent configuration.""" id: str agent_uri: str protocol: Protocol auth_token: str | None = None requires_auth: bool = False auth_header: str = "x-adcp-auth" # Header name for authentication auth_type: str = "token" # "token" for direct value, "bearer" for "Bearer {token}" timeout: float = 30.0 # Request timeout in seconds mcp_transport: str = ( "streamable_http" # "streamable_http" (default, modern) or "sse" (legacy fallback) ) debug: bool = False # Enable debug mode to capture request/response details @field_validator("agent_uri") @classmethod def validate_agent_uri(cls, v: str) -> str: """Validate agent URI format.""" if not v: raise ValueError("agent_uri cannot be empty") if not v.startswith(("http://", "https://")): raise ValueError( f"agent_uri must start with http:// or https://, got: {v}\n" "Example: https://agent.example.com" ) # Remove trailing slash for consistency return v.rstrip("/") @field_validator("timeout") @classmethod def validate_timeout(cls, v: float) -> float: """Validate timeout is reasonable.""" if v <= 0: raise ValueError(f"timeout must be positive, got: {v}") if v > 300: # 5 minutes raise ValueError( f"timeout is very large ({v}s). Consider a value under 300 seconds.\n" "Large timeouts can cause long hangs if agent is unresponsive." ) return v @field_validator("mcp_transport") @classmethod def validate_mcp_transport(cls, v: str) -> str: """Validate MCP transport type.""" valid_transports = ["streamable_http", "sse"] if v not in valid_transports: raise ValueError( f"mcp_transport must be one of {valid_transports}, got: {v}\n" "Use 'streamable_http' for modern agents (recommended)" ) return v @field_validator("auth_type") @classmethod def validate_auth_type(cls, v: str) -> str: """Validate auth type.""" valid_types = ["token", "bearer"] if v not in valid_types: raise ValueError( f"auth_type must be one of {valid_types}, got: {v}\n" "Use 'bearer' for OAuth2/standard Authorization header" ) return vAgent configuration.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var agent_uri : strvar auth_header : strvar auth_token : str | Nonevar auth_type : strvar debug : boolvar id : strvar mcp_transport : strvar model_configvar protocol : Protocolvar requires_auth : boolvar timeout : float
Static methods
def validate_agent_uri(v: str) ‑> str-
Validate agent URI format.
def validate_auth_type(v: str) ‑> str-
Validate auth type.
def validate_mcp_transport(v: str) ‑> str-
Validate MCP transport type.
def validate_timeout(v: float) ‑> float-
Validate timeout is reasonable.
class AggregatedTotals (**data: Any)-
Expand source code
class AggregatedTotals(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) clicks: Annotated[ float | None, Field(description='Total clicks across all media buys (if applicable)', ge=0.0), ] = None completed_views: Annotated[ float | None, Field( description='Total audio/video completions across all media buys (if applicable)', ge=0.0, ), ] = None completion_rate: Annotated[ float | None, Field( description='Aggregate completion rate across all media buys (weighted by impressions, not a simple average of per-buy rates)', ge=0.0, le=1.0, ), ] = None conversion_value: Annotated[ float | None, Field(description='Total conversion value across all media buys (if applicable)', ge=0.0), ] = None conversions: Annotated[ float | None, Field(description='Total conversions across all media buys (if applicable)', ge=0.0), ] = None cost_per_acquisition: Annotated[ float | None, Field( description='Aggregate cost per conversion across all media buys (total spend / total conversions)', ge=0.0, ), ] = None frequency: Annotated[ float | None, Field( description='Average frequency per reach unit across all media buys (impressions / reach when cross-buy deduplication is available). Only present when reach is present.', ge=0.0, ), ] = None impressions: Annotated[ float, Field(description='Total impressions delivered across all media buys', ge=0.0) ] media_buy_count: Annotated[ int, Field(description='Number of media buys included in the response', ge=0) ] new_to_brand_rate: Annotated[ float | None, Field( description='Fraction of total conversions across all media buys from first-time brand buyers (weighted by conversion volume, not a simple average of per-buy rates)', ge=0.0, le=1.0, ), ] = None reach: Annotated[ float | None, Field( description='Deduplicated reach across all media buys (if the seller can deduplicate across buys; otherwise sum of per-buy reach). Only present when all media buys share the same reach_unit. Omitted when reach units are heterogeneous — use per-buy reach values instead.', ge=0.0, ), ] = None reach_unit: Annotated[ reach_unit_1.ReachUnit | None, Field( description='Unit of measurement for reach. Only present when all aggregated media buys use the same reach_unit.' ), ] = None roas: Annotated[ float | None, Field( description='Aggregate return on ad spend across all media buys (total conversion_value / total spend)', ge=0.0, ), ] = None spend: Annotated[float, Field(description='Total amount spent across all media buys', ge=0.0)] views: Annotated[ float | None, Field(description='Total views across all media buys (if applicable)', ge=0.0) ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var clicks : float | Nonevar completed_views : float | Nonevar completion_rate : float | Nonevar conversion_value : float | Nonevar conversions : float | Nonevar cost_per_acquisition : float | Nonevar frequency : float | Nonevar impressions : floatvar media_buy_count : intvar model_configvar new_to_brand_rate : float | Nonevar reach : float | Nonevar reach_unit : ReachUnit | Nonevar roas : float | Nonevar spend : floatvar views : float | None
Inherited members
class Artifact (**data: Any)-
Expand source code
class Artifact(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) artifact_id: Annotated[ str, Field( description="Identifier for this artifact within the property. The property owner defines the scheme (e.g., 'article_12345', 'episode_42_segment_3', 'post_abc123')." ), ] assets: Annotated[ list[Assets | Assets1 | Assets2 | Assets3], Field( description='Artifact assets in document flow order - text blocks, images, video, audio', max_length=200, ), ] format_id: Annotated[ format_id_1.FormatId | None, Field( description='Optional reference to a format definition. Uses the same format registry as creative formats.' ), ] = None identifiers: Annotated[ Identifiers | None, Field(description='Platform-specific identifiers for this artifact') ] = None last_update_time: Annotated[ AwareDatetime | None, Field(description='When the artifact was last modified (ISO 8601 format)'), ] = None metadata: Annotated[ Metadata | None, Field(description='Rich metadata extracted from the artifact') ] = None property_rid: Annotated[ str, Field( description='Stable property identifier from the property catalog. Globally unique across the ecosystem.' ), ] provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this artifact. Serves as the default provenance for all assets within this artifact — individual assets can override with their own provenance.' ), ] = None published_time: Annotated[ AwareDatetime | None, Field(description='When the artifact was published (ISO 8601 format)') ] = None url: Annotated[ AnyUrl | None, Field( description='Optional URL for this artifact (web page, podcast feed, video page). Not all artifacts have URLs (e.g., Instagram content, podcast segments, TV scenes).' ), ] = None variant_id: Annotated[ str | None, Field( description="Identifies a specific variant of this artifact. Use for A/B tests, translations, or temporal versions. Examples: 'en', 'es-MX', 'v2', 'headline_test_b'. The combination of artifact_id + variant_id must be unique." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var artifact_id : strvar assets : list[Assets | Assets1 | Assets2 | Assets3]var format_id : FormatId | Nonevar identifiers : Identifiers | Nonevar last_update_time : pydantic.types.AwareDatetime | Nonevar metadata : Metadata | Nonevar model_configvar property_rid : strvar provenance : Provenance | Nonevar published_time : pydantic.types.AwareDatetime | Nonevar url : pydantic.networks.AnyUrl | Nonevar variant_id : str | None
Inherited members
class ArtifactWebhookPayload (**data: Any)-
Expand source code
class ArtifactWebhookPayload(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) artifacts: Annotated[ list[Artifact], Field(description='Content artifacts from delivered impressions') ] batch_id: Annotated[ str, Field( description='Unique identifier for this batch of artifacts. Use for deduplication and acknowledgment.' ), ] ext: ext_1.ExtensionObject | None = None media_buy_id: Annotated[ str, Field(description='Media buy identifier these artifacts belong to') ] pagination: Annotated[ Pagination | None, Field(description='Pagination info when batching large artifact sets') ] = None timestamp: Annotated[ AwareDatetime, Field(description='When this batch was generated (ISO 8601)') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var artifacts : list[Artifact]var batch_id : strvar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar pagination : Pagination | Nonevar timestamp : pydantic.types.AwareDatetime
Inherited members
class Asset (**data: Any)-
Expand source code
class Asset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) asset_id: Annotated[str, Field(description='Unique identifier')] asset_type: Annotated[ asset_content_type.AssetContentType, Field(description='Type of asset content') ] description: Annotated[str | None, Field(description='Asset description or usage notes')] = None duration_seconds: Annotated[ float | None, Field(description='Video/audio duration in seconds') ] = None file_size_bytes: Annotated[int | None, Field(description='File size in bytes')] = None format: Annotated[str | None, Field(description="File format (e.g., 'jpg', 'mp4')")] = None height: Annotated[int | None, Field(description='Image/video height in pixels')] = None name: Annotated[str | None, Field(description='Human-readable name')] = None tags: Annotated[list[str] | None, Field(description='Tags for discovery')] = None url: Annotated[AnyUrl, Field(description='URL to CDN-hosted asset file')] width: Annotated[int | None, Field(description='Image/video width in pixels')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var asset_id : strvar asset_type : AssetContentTypevar description : str | Nonevar duration_seconds : float | Nonevar file_size_bytes : int | Nonevar format : str | Nonevar height : int | Nonevar model_configvar name : str | Nonevar url : pydantic.networks.AnyUrlvar width : int | None
Inherited members
class AssetContentType (*args, **kwds)-
Expand source code
class AssetContentType(Enum): image = 'image' video = 'video' audio = 'audio' text = 'text' markdown = 'markdown' html = 'html' css = 'css' javascript = 'javascript' vast = 'vast' daast = 'daast' url = 'url' webhook = 'webhook' brief = 'brief' catalog = 'catalog'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var audiovar briefvar catalogvar cssvar daastvar htmlvar imagevar javascriptvar markdownvar textvar urlvar vastvar videovar webhook
class AssetType (*args, **kwds)-
Expand source code
class AssetContentType(Enum): image = 'image' video = 'video' audio = 'audio' text = 'text' markdown = 'markdown' html = 'html' css = 'css' javascript = 'javascript' vast = 'vast' daast = 'daast' url = 'url' webhook = 'webhook' brief = 'brief' catalog = 'catalog'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var audiovar briefvar catalogvar cssvar daastvar htmlvar imagevar javascriptvar markdownvar textvar urlvar vastvar videovar webhook
class AssignedPackage (**data: Any)-
Expand source code
class AssignedPackage(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assigned_date: Annotated[AwareDatetime, Field(description='When this assignment was created')] package_id: Annotated[str, Field(description='Package identifier')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assigned_date : pydantic.types.AwareDatetimevar model_configvar package_id : str
Inherited members
class Assignments (**data: Any)-
Expand source code
class Assignments(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assigned_packages: Annotated[ list[AssignedPackage] | None, Field(description='List of packages this creative is assigned to'), ] = None assignment_count: Annotated[ int, Field(description='Total number of active package assignments', ge=0) ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assigned_packages : list[AssignedPackage] | Nonevar assignment_count : intvar model_config
Inherited members
class SyncAudiencesAudience (**data: Any)-
Expand source code
class Audience(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) add: Annotated[ list[audience_member.AudienceMember] | None, Field( description='Members to add to this audience. Hashed before sending — normalize emails to lowercase+trim, phones to E.164.', min_length=1, ), ] = None audience_id: Annotated[ str, Field( description="Buyer's identifier for this audience. Used to reference the audience in targeting overlays." ), ] audience_type: Annotated[ AudienceType | None, Field( description="Intended use for this audience. 'crm': target these users. 'suppression': exclude these users from delivery. 'lookalike_seed': use as a seed for the seller's lookalike modeling. Sellers may handle audiences differently based on type (e.g., suppression lists bypass minimum size requirements on some platforms)." ), ] = None consent_basis: Annotated[ consent_basis_1.ConsentBasis | None, Field( description='GDPR lawful basis for processing this audience list. Informational — not validated by the protocol, but required by some sellers operating in regulated markets (e.g. EU). When omitted, the buyer asserts they have a lawful basis appropriate to their jurisdiction.' ), ] = None delete: Annotated[ bool | None, Field( description='When true, delete this audience from the account entirely. All other fields on this audience object are ignored. Use this to delete a specific audience without affecting others.' ), ] = None description: Annotated[ str | None, Field( description="Human-readable description of this audience's composition or purpose (e.g., 'High-value customers who purchased in the last 90 days')." ), ] = None name: Annotated[str | None, Field(description='Human-readable name for this audience')] = None remove: Annotated[ list[audience_member.AudienceMember] | None, Field( description='Members to remove from this audience. If the same identifier appears in both add and remove in a single request, remove takes precedence.', min_length=1, ), ] = None tags: Annotated[ list[Tag] | None, Field( description="Buyer-defined tags for organizing and filtering audiences (e.g., 'holiday_2026', 'high_ltv'). Tags are stored by the seller and returned in discovery-only calls." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var add : list[AudienceMember] | Nonevar audience_id : strvar audience_type : AudienceType | Nonevar consent_basis : ConsentBasis | Nonevar delete : bool | Nonevar description : str | Nonevar model_configvar name : str | Nonevar remove : list[AudienceMember] | None
Inherited members
class AudienceSource (*args, **kwds)-
Expand source code
class AudienceSource(Enum): synced = 'synced' platform = 'platform' third_party = 'third_party' lookalike = 'lookalike' retargeting = 'retargeting' unknown = 'unknown'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var lookalikevar platformvar retargetingvar syncedvar third_partyvar unknown
class AudioAsset (**data: Any)-
Expand source code
class AudioAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) bit_depth: Annotated[BitDepth | None, Field(description='Bit depth')] = None bitrate_kbps: Annotated[ int | None, Field(description='Bitrate in kilobits per second', ge=1) ] = None channels: Annotated[Channels | None, Field(description='Channel configuration')] = None codec: Annotated[ str | None, Field( description='Audio codec used (aac, aac_lc, he_aac, pcm, mp3, vorbis, opus, flac, ac3, eac3, etc.)' ), ] = None container_format: Annotated[ str | None, Field(description='Audio container/file format (mp3, m4a, aac, wav, ogg, flac, etc.)'), ] = None duration_ms: Annotated[ int | None, Field(description='Audio duration in milliseconds', ge=0) ] = None file_size_bytes: Annotated[int | None, Field(description='File size in bytes', ge=1)] = None loudness_lufs: Annotated[float | None, Field(description='Integrated loudness in LUFS')] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None sampling_rate_hz: Annotated[ int | None, Field(description='Sampling rate in Hz (e.g., 44100, 48000, 96000)') ] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = None true_peak_dbfs: Annotated[float | None, Field(description='True peak level in dBFS')] = None url: Annotated[AnyUrl, Field(description='URL to the audio asset')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bit_depth : BitDepth | Nonevar bitrate_kbps : int | Nonevar channels : Channels | Nonevar codec : str | Nonevar container_format : str | Nonevar duration_ms : int | Nonevar file_size_bytes : int | Nonevar loudness_lufs : float | Nonevar model_configvar provenance : Provenance | Nonevar sampling_rate_hz : int | Nonevar transcript_url : pydantic.networks.AnyUrl | Nonevar true_peak_dbfs : float | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class Authentication (**data: Any)-
Expand source code
class Authentication(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) credentials: Annotated[ str, Field( description='Credentials for authentication. For Bearer: token sent in Authorization header. For HMAC-SHA256: shared secret used to generate signature. Minimum 32 characters. Exchanged out-of-band during onboarding.', min_length=32, ), ] schemes: Annotated[ list[auth_scheme.AuthenticationScheme], Field( description="Array of authentication schemes. Supported: ['Bearer'] for simple token auth, ['HMAC-SHA256'] for signature verification (recommended for production)", max_length=1, min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var credentials : strvar model_configvar schemes : list[AuthenticationScheme]
Inherited members
class AuthenticationScheme (*args, **kwds)-
Expand source code
class AuthenticationScheme(Enum): Bearer = 'Bearer' HMAC_SHA256 = 'HMAC-SHA256'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var Bearervar HMAC_SHA256
class Scheme (*args, **kwds)-
Expand source code
class AuthenticationScheme(Enum): Bearer = 'Bearer' HMAC_SHA256 = 'HMAC-SHA256'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var Bearervar HMAC_SHA256
class AuthorizedAgents (**data: Any)-
Expand source code
class AuthorizedAgents(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['property_ids'], Field(description='Discriminator indicating authorization by specific property IDs'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.', min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.', min_length=1, ), ] = None delegation_type: Annotated[ DelegationType | None, Field( description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint." ), ] = None effective_from: Annotated[ AwareDatetime | None, Field(description='Optional start time for this authorization window.'), ] = None effective_until: Annotated[ AwareDatetime | None, Field(description='Optional end time for this authorization window.') ] = None exclusive: Annotated[ bool | None, Field( description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory." ), ] = None placement_ids: Annotated[ list[str] | None, Field( description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.', min_length=1, ), ] = None placement_tags: Annotated[ list[str] | None, Field( description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.', min_length=1, ), ] = None property_ids: Annotated[ list[property_id.PropertyId], Field( description='Property IDs this agent is authorized for. Resolved against the top-level properties array in this file', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var collections : list[CollectionSelector] | Nonevar countries : list[Country] | Nonevar delegation_type : DelegationType | Nonevar effective_from : pydantic.types.AwareDatetime | Nonevar effective_until : pydantic.types.AwareDatetime | Nonevar exclusive : bool | Nonevar model_configvar placement_ids : list[str] | Nonevar property_ids : list[PropertyId]var signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
class AuthorizedAgentsByPropertyId (**data: Any)-
Expand source code
class AuthorizedAgents(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['property_ids'], Field(description='Discriminator indicating authorization by specific property IDs'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.', min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.', min_length=1, ), ] = None delegation_type: Annotated[ DelegationType | None, Field( description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint." ), ] = None effective_from: Annotated[ AwareDatetime | None, Field(description='Optional start time for this authorization window.'), ] = None effective_until: Annotated[ AwareDatetime | None, Field(description='Optional end time for this authorization window.') ] = None exclusive: Annotated[ bool | None, Field( description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory." ), ] = None placement_ids: Annotated[ list[str] | None, Field( description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.', min_length=1, ), ] = None placement_tags: Annotated[ list[str] | None, Field( description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.', min_length=1, ), ] = None property_ids: Annotated[ list[property_id.PropertyId], Field( description='Property IDs this agent is authorized for. Resolved against the top-level properties array in this file', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var collections : list[CollectionSelector] | Nonevar countries : list[Country] | Nonevar delegation_type : DelegationType | Nonevar effective_from : pydantic.types.AwareDatetime | Nonevar effective_until : pydantic.types.AwareDatetime | Nonevar exclusive : bool | Nonevar model_configvar placement_ids : list[str] | Nonevar property_ids : list[PropertyId]var signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByPropertyTag (**data: Any)-
Expand source code
class AuthorizedAgents1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['property_tags'], Field(description='Discriminator indicating authorization by property tags'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.', min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.', min_length=1, ), ] = None delegation_type: Annotated[ DelegationType | None, Field( description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint." ), ] = None effective_from: Annotated[ AwareDatetime | None, Field(description='Optional start time for this authorization window.'), ] = None effective_until: Annotated[ AwareDatetime | None, Field(description='Optional end time for this authorization window.') ] = None exclusive: Annotated[ bool | None, Field( description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory." ), ] = None placement_ids: Annotated[ list[str] | None, Field( description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.', min_length=1, ), ] = None placement_tags: Annotated[ list[str] | None, Field( description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.', min_length=1, ), ] = None property_tags: Annotated[ list[property_tag.PropertyTag], Field( description='Tags identifying which properties this agent is authorized for. Resolved against the top-level properties array in this file using tag matching', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var collections : list[CollectionSelector] | Nonevar countries : list[Country] | Nonevar delegation_type : DelegationType | Nonevar effective_from : pydantic.types.AwareDatetime | Nonevar effective_until : pydantic.types.AwareDatetime | Nonevar exclusive : bool | Nonevar model_configvar placement_ids : list[str] | Nonevar signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByInlineProperties (**data: Any)-
Expand source code
class AuthorizedAgents2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['inline_properties'], Field(description='Discriminator indicating authorization by inline property definitions'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.', min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.', min_length=1, ), ] = None delegation_type: Annotated[ DelegationType | None, Field( description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint." ), ] = None effective_from: Annotated[ AwareDatetime | None, Field(description='Optional start time for this authorization window.'), ] = None effective_until: Annotated[ AwareDatetime | None, Field(description='Optional end time for this authorization window.') ] = None exclusive: Annotated[ bool | None, Field( description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory." ), ] = None placement_ids: Annotated[ list[str] | None, Field( description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.', min_length=1, ), ] = None placement_tags: Annotated[ list[str] | None, Field( description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.', min_length=1, ), ] = None properties: Annotated[ list[property.Property], Field( description='Specific properties this agent is authorized for (alternative to property_ids/property_tags)', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var collections : list[CollectionSelector] | Nonevar countries : list[Country] | Nonevar delegation_type : DelegationType | Nonevar effective_from : pydantic.types.AwareDatetime | Nonevar effective_until : pydantic.types.AwareDatetime | Nonevar exclusive : bool | Nonevar model_configvar placement_ids : list[str] | Nonevar properties : list[Property]var signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByPublisherProperties (**data: Any)-
Expand source code
class AuthorizedAgents3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['publisher_properties'], Field( description='Discriminator indicating authorization for properties from other publisher domains' ), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Optional collection constraints. When present, authorization only applies to inventory associated with these collections.', min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description='Optional ISO 3166-1 alpha-2 country codes limiting where this authorization applies. Omit for worldwide authorization.', min_length=1, ), ] = None delegation_type: Annotated[ DelegationType | None, Field( description="Commercial relationship for this inventory path. 'direct' means the publisher treats this as a direct way to buy from them, even if a third party operates the software. 'delegated' means the agent is authorized to sell on the publisher's behalf. 'ad_network' means the inventory is sold as part of a network/package context rather than as the publisher's direct endpoint." ), ] = None effective_from: Annotated[ AwareDatetime | None, Field(description='Optional start time for this authorization window.'), ] = None effective_until: Annotated[ AwareDatetime | None, Field(description='Optional end time for this authorization window.') ] = None exclusive: Annotated[ bool | None, Field( description="Whether this agent is the publisher's sole authorized path for the scoped inventory slice. When false or absent, other authorized agents may also sell the same inventory." ), ] = None placement_ids: Annotated[ list[str] | None, Field( description='Optional placement constraints. When present, authorization only applies to these placement IDs from the top-level placements array in this file.', min_length=1, ), ] = None placement_tags: Annotated[ list[str] | None, Field( description='Optional placement tag constraints. When present, authorization only applies to placements whose tags include any of these publisher-defined values.', min_length=1, ), ] = None publisher_properties: Annotated[ list[publisher_property_selector.PublisherPropertySelector], Field( description='Properties from other publisher domains this agent is authorized for. Each entry specifies a publisher domain and which of their properties this agent can sell', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var collections : list[CollectionSelector] | Nonevar countries : list[Country] | Nonevar delegation_type : DelegationType | Nonevar effective_from : pydantic.types.AwareDatetime | Nonevar effective_until : pydantic.types.AwareDatetime | Nonevar exclusive : bool | Nonevar model_configvar placement_ids : list[str] | Nonevar publisher_properties : list[PublisherPropertySelector]var signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsBySignalId (**data: Any)-
Expand source code
class AuthorizedAgents4(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['signal_ids'], Field(description='Discriminator indicating authorization by specific signal IDs'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what signals this agent is authorized to resell', max_length=500, min_length=1, ), ] signal_ids: Annotated[ list[SignalId], Field( description='Signal IDs this agent is authorized to resell. Resolved against the top-level signals array in this file', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar signal_ids : list[SignalId]var signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsBySignalTag (**data: Any)-
Expand source code
class AuthorizedAgents5(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authorization_type: Annotated[ Literal['signal_tags'], Field(description='Discriminator indicating authorization by signal tags'), ] authorized_for: Annotated[ str, Field( description='Human-readable description of what signals this agent is authorized to resell', max_length=500, min_length=1, ), ] signal_tags: Annotated[ list[SignalTag], Field( description='Signal tags this agent is authorized for. Agent can resell all signals with these tags', min_length=1, ), ] signing_keys: Annotated[ list[agent_signing_key.AgentSigningKey] | None, Field( description='Optional publisher-attested public signing keys for this agent. Use these as the trust anchor for verifying signed agent responses instead of relying on key discovery from the agent domain alone.', min_length=1, ), ] = None url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar signing_keys : list[AgentSigningKey] | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class AvailableMetric (*args, **kwds)-
Expand source code
class AvailableMetric(Enum): impressions = 'impressions' spend = 'spend' clicks = 'clicks' ctr = 'ctr' video_completions = 'video_completions' completion_rate = 'completion_rate' conversions = 'conversions' conversion_value = 'conversion_value' roas = 'roas' cost_per_acquisition = 'cost_per_acquisition' new_to_brand_rate = 'new_to_brand_rate' viewability = 'viewability' engagement_rate = 'engagement_rate' views = 'views' completed_views = 'completed_views' leads = 'leads' reach = 'reach' frequency = 'frequency' grps = 'grps' quartile_data = 'quartile_data' dooh_metrics = 'dooh_metrics' cost_per_click = 'cost_per_click'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var clicksvar completed_viewsvar completion_ratevar conversion_valuevar conversionsvar cost_per_acquisitionvar cost_per_clickvar ctrvar dooh_metricsvar engagement_ratevar frequencyvar grpsvar impressionsvar leadsvar new_to_brand_ratevar quartile_datavar reachvar roasvar spendvar video_completionsvar viewabilityvar views
class AvailablePackage (**data: Any)-
Expand source code
class AvailablePackage(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) catalogs: Annotated[ list[catalog.Catalog] | None, Field( description="The buyer's catalogs attached to this package, with selectors (ids, gtins, tags, category, query) scoping which items are in play. References synced catalogs by catalog_id. The provider resolves items from its cached copy." ), ] = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Creative format identifiers eligible for this package. Uses the standard AdCP format-id object with agent_url and id for unambiguous format resolution across namespaces.' ), ] = None media_buy_id: Annotated[str, Field(description='Media buy that this package belongs to')] package_id: Annotated[str, Field(description='Unique identifier for the package')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalogs : list[Catalog] | Nonevar format_ids : list[FormatId] | Nonevar media_buy_id : strvar model_configvar package_id : str
Inherited members
class BrandReference (**data: Any)-
Expand source code
class BrandReference(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) brand_id: Annotated[ brand_id_1.BrandId | None, Field( description='Brand identifier within the house portfolio. Optional for single-brand domains.' ), ] = None domain: Annotated[ str, Field( description="Domain where /.well-known/brand.json is hosted, or the brand's operating domain", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand_id : BrandId | Nonevar domain : strvar model_config
Inherited members
class BuildCreativeRequest (**data: Any)-
Expand source code
class BuildCreativeRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for creative generation. Resolved to full brand identity (colors, logos, tone) at execution time.' ), ] = None concept_id: Annotated[ str | None, Field( description='Creative concept containing the creative. Creative agents SHOULD assign globally unique creative_id values; when they cannot guarantee uniqueness, concept_id is REQUIRED to disambiguate.' ), ] = None context: context_1.ContextObject | None = None creative_id: Annotated[ str | None, Field( description="Reference to a creative in the agent's library. The creative agent resolves this to a manifest from its library. Use this instead of creative_manifest when retrieving an existing creative for tag generation or format adaptation." ), ] = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest | None, Field( description='Creative manifest to transform or generate from. For pure generation, this should include the target format_id and any required input assets. For transformation (e.g., resizing, reformatting), this is the complete creative to adapt. When creative_id is provided, the agent resolves the creative from its library and this field is ignored.' ), ] = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate creative generation on 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, ), ] = None include_preview: Annotated[ bool | None, Field( description="When true, requests the creative agent to include preview renders in the response alongside the manifest. Agents that support this return a 'preview' object in the response using the same structure as preview_creative. Agents that do not support inline preview simply omit the field. This avoids a separate preview_creative round trip for platforms that generate previews as a byproduct of building." ), ] = None item_limit: Annotated[ int | None, Field( description="Maximum number of catalog items to use when generating. When a catalog asset contains more items than this limit, the creative agent selects the top items based on relevance or catalog ordering. When item_limit exceeds the format's max_items, the creative agent SHOULD use the lesser of the two. Ignored when the manifest contains no catalog assets.", ge=1, ), ] = None macro_values: Annotated[ dict[str, str] | None, Field( description="Macro values to pre-substitute into the output manifest's assets. Keys are universal macro names (e.g., CLICK_URL, CACHEBUSTER); values are the substitution strings. The creative agent translates universal macros to its platform's native syntax. Substitution is literal — all occurrences of each macro in output assets are replaced with the provided value. The caller is responsible for URL-encoding values if the output context requires it. Macros not provided here remain as {MACRO} placeholders for the sales agent to resolve at serve time. Creative agents MUST ignore keys they do not recognize — unknown macro names are not an error." ), ] = None media_buy_id: Annotated[ str | None, Field( description='Media buy identifier for tag generation context. When the creative agent is also the ad server, this provides the trafficking context needed to generate placement-specific tags (e.g., CM360 placement ID). Not needed when tags are generated at the creative level (most creative platforms).' ), ] = None message: Annotated[ str | None, Field( description='Natural language instructions for the transformation or generation. For pure generation, this is the creative brief. For transformation, this provides guidance on how to adapt the creative. For refinement, this describes the desired changes.' ), ] = None package_id: Annotated[ str | None, Field( description='Package identifier within the media buy. Used with media_buy_id when the creative agent needs line-item-level context for tag generation. Omit to get a tag not scoped to a specific package.' ), ] = None preview_inputs: Annotated[ list[PreviewInput] | None, Field( description='Input sets for preview generation when include_preview is true. Each input set defines macros and context values for one preview variant. If include_preview is true but this is omitted, the agent generates a single default preview. Only supported with target_format_id (single-format requests). Ignored when using target_format_ids — multi-format requests generate one default preview per format. Ignored when include_preview is false or omitted.', min_length=1, ), ] = None preview_output_format: Annotated[ preview_output_format_1.PreviewOutputFormat | None, Field( description="Output format for preview renders when include_preview is true. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML). Ignored when include_preview is false or omitted." ), ] = preview_output_format_1.PreviewOutputFormat.url preview_quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Render quality for inline preview when include_preview is true. 'draft' produces fast, lower-fidelity renderings. 'production' produces full-quality renderings. Independent of the build quality parameter — you can build at draft quality and preview at production quality, or vice versa. If omitted, the creative agent uses its own default. Ignored when include_preview is false or omitted." ), ] = None quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Quality tier for generation. 'draft' produces fast, lower-fidelity output for iteration and review. 'production' produces full-quality output for final delivery. If omitted, the creative agent uses its own default. For non-generative transforms (e.g., format resizing), creative agents MAY ignore this field." ), ] = None target_format_id: Annotated[ format_id.FormatId | None, Field( description='Single format ID to generate. Mutually exclusive with target_format_ids. The format definition specifies required input assets and output structure.' ), ] = None target_format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Array of format IDs to generate in a single call. Mutually exclusive with target_format_id. The creative agent produces one manifest per format. Each format definition specifies its own required input assets and output structure.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand : BrandReference | Nonevar concept_id : str | Nonevar context : ContextObject | Nonevar creative_id : str | Nonevar creative_manifest : CreativeManifest | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar include_preview : bool | Nonevar item_limit : int | Nonevar macro_values : dict[str, str] | Nonevar media_buy_id : str | Nonevar message : str | Nonevar model_configvar package_id : str | Nonevar preview_inputs : list[PreviewInput] | Nonevar preview_output_format : PreviewOutputFormat | Nonevar preview_quality : CreativeQuality | Nonevar quality : CreativeQuality | Nonevar target_format_id : FormatId | Nonevar target_format_ids : list[FormatId] | None
Inherited members
class BuildCreativeSuccessResponse (**data: Any)-
Expand source code
class BuildCreativeResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='The generated or transformed creative manifest'), ] expires_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when generated asset URLs in the manifest expire. Set to the earliest expiration across all generated assets. Re-build the creative after this time to get fresh URLs.' ), ] = None ext: ext_1.ExtensionObject | None = None preview: Annotated[ Preview | None, Field( description='Preview renders included when the request set include_preview to true and the agent supports it. Contains the same content fields as a preview_creative single response (previews, interactive_url, expires_at) minus the response_type discriminator, so clients can reuse the same preview rendering logic.' ), ] = None preview_error: Annotated[ error.Error | None, Field( description="When include_preview was true in the request but preview generation failed. Uses the standard error structure with code, message, and recovery classification. Distinguishes 'agent does not support inline preview' (preview and preview_error both absent) from 'preview generation failed' (preview absent, preview_error present). Omitted when preview succeeded or was not requested." ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_manifest : CreativeManifestvar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar model_configvar preview : Preview | Nonevar preview_error : Error | Nonevar sandbox : bool | None
Inherited members
class BuildCreativeErrorResponse (**data: Any)-
Expand source code
class BuildCreativeResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_manifests: Annotated[ list[creative_manifest_1.CreativeManifest], Field( description='Array of generated creative manifests, one per requested format. Each manifest contains its own format_id identifying which format it was generated for.', min_length=1, ), ] expires_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when the earliest generated asset URL expires across all manifests. Re-build after this time to get fresh URLs.' ), ] = None ext: ext_1.ExtensionObject | None = None preview: Annotated[ Preview2 | None, Field( description='Preview renders included when the request set include_preview to true and the agent supports it. Contains one default preview per requested format. preview_inputs is ignored for multi-format requests.' ), ] = None preview_error: Annotated[ error.Error | None, Field( description='When include_preview was true in the request but preview generation failed. Uses the standard error structure with code, message, and recovery classification. Omitted when preview succeeded or was not requested.' ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_manifests : list[CreativeManifest]var expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar model_configvar preview : Preview2 | Nonevar preview_error : Error | Nonevar sandbox : bool | None
Inherited members
class BuyingMode (*args, **kwds)-
Expand source code
class BuyingMode(Enum): brief = 'brief' wholesale = 'wholesale' refine = 'refine'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var briefvar refinevar wholesale
class ByCatalogItemItem (**data: Any)-
Expand source code
class ByCatalogItemItem(DeliveryMetrics): content_id: Annotated[ str, Field(description='Catalog item identifier (e.g., SKU, GTIN, job_id, offering_id)') ] content_id_type: Annotated[ content_id_type_1.ContentIdType | None, Field(description='Identifier type for this content_id'), ] = None impressions: Any spend: AnyBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- DeliveryMetrics
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var content_id : strvar content_id_type : ContentIdType | Nonevar impressions : Anyvar model_configvar spend : Any
Inherited members
class ByPackageItem (**data: Any)-
Expand source code
class ByPackageItem(DeliveryMetrics): by_audience: Annotated[ list[ByAudienceItem] | None, Field( description="Delivery by audience segment within this package. Available when the buyer requests audience breakdown via reporting_dimensions and the seller supports it. Only 'synced' audiences are directly targetable via the targeting overlay; other sources are informational." ), ] = None by_audience_truncated: Annotated[ bool | None, Field( description='Whether by_audience was truncated. Sellers MUST return this flag whenever by_audience is present (false means the list is complete).' ), ] = None by_catalog_item: Annotated[ list[ByCatalogItemItem] | None, Field( description='Delivery by catalog item within this package. Available for catalog-driven packages when the seller supports item-level reporting.' ), ] = None by_creative: Annotated[ list[ByCreativeItem] | None, Field( description='Metrics broken down by creative within this package. Available when the seller supports creative-level reporting.' ), ] = None by_device_platform: Annotated[ list[ByDevicePlatformItem] | None, Field( description='Delivery by operating system within this package. Available when the buyer requests device_platform breakdown via reporting_dimensions and the seller supports it. Useful for CTV campaigns where tvOS vs Roku OS vs Fire OS matters.' ), ] = None by_device_platform_truncated: Annotated[ bool | None, Field( description='Whether by_device_platform was truncated. Sellers MUST return this flag whenever by_device_platform is present (false means the list is complete).' ), ] = None by_device_type: Annotated[ list[ByDeviceTypeItem] | None, Field( description='Delivery by device form factor within this package. Available when the buyer requests device_type breakdown via reporting_dimensions and the seller supports it.' ), ] = None by_device_type_truncated: Annotated[ bool | None, Field( description='Whether by_device_type was truncated. Sellers MUST return this flag whenever by_device_type is present (false means the list is complete).' ), ] = None by_geo: Annotated[ list[ByGeoItem] | None, Field( description="Delivery by geographic area within this package. Available when the buyer requests geo breakdown via reporting_dimensions and the seller supports it. Each dimension's rows are independent slices that should sum to the package total." ), ] = None by_geo_truncated: Annotated[ bool | None, Field( description='Whether by_geo was truncated due to the requested limit or a seller-imposed maximum. Sellers MUST return this flag whenever by_geo is present (false means the list is complete).' ), ] = None by_keyword: Annotated[ list[ByKeywordItem] | None, Field( description='Metrics broken down by keyword within this package. One row per (keyword, match_type) pair — the same keyword with different match types appears as separate rows. Keyword-grain only: rows reflect aggregate performance of each targeted keyword, not individual search queries. Rows may not sum to package totals when a single impression is attributed to the triggering keyword only. Available for search and retail media packages when the seller supports keyword-level reporting.' ), ] = None by_placement: Annotated[ list[ByPlacementItem] | None, Field( description="Delivery by placement within this package. Available when the buyer requests placement breakdown via reporting_dimensions and the seller supports it. Placement IDs reference the product's placements array." ), ] = None by_placement_truncated: Annotated[ bool | None, Field( description='Whether by_placement was truncated. Sellers MUST return this flag whenever by_placement is present (false means the list is complete).' ), ] = None currency: Annotated[ str, Field( description="ISO 4217 currency code (e.g., USD, EUR, GBP) for this package's pricing. Indicates the currency in which the rate and spend values are denominated. Different packages can use different currencies when supported by the publisher.", pattern='^[A-Z]{3}$', ), ] daily_breakdown: Annotated[ list[DailyBreakdownItem] | None, Field( description='Day-by-day delivery for this package. Only present when include_package_daily_breakdown is true in the request. Enables per-package pacing analysis and line-item monitoring.' ), ] = None delivery_status: Annotated[ DeliveryStatus | None, Field( description='System-reported operational state of this package. Reflects actual delivery state independent of buyer pause control.' ), ] = None pacing_index: Annotated[ float | None, Field(description='Delivery pace (1.0 = on track, <1.0 = behind, >1.0 = ahead)', ge=0.0), ] = None package_id: Annotated[str, Field(description="Seller's package identifier")] paused: Annotated[ bool | None, Field(description='Whether this package is currently paused by the buyer') ] = None pricing_model: Annotated[ pricing_model_1.PricingModel, Field( description='The pricing model used for this package (e.g., cpm, cpcv, cpp). Indicates how the package is billed and which metrics are most relevant for optimization.' ), ] rate: Annotated[ float, Field( description='The pricing rate for this package in the specified currency. For fixed-rate pricing, this is the agreed rate (e.g., CPM rate of 12.50 means $12.50 per 1,000 impressions). For auction-based pricing, this represents the effective rate based on actual delivery.', ge=0.0, ), ] spend: AnyBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- DeliveryMetrics
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var by_audience : list[ByAudienceItem] | Nonevar by_audience_truncated : bool | Nonevar by_catalog_item : list[ByCatalogItemItem] | Nonevar by_creative : list[ByCreativeItem] | Nonevar by_device_platform : list[ByDevicePlatformItem] | Nonevar by_device_platform_truncated : bool | Nonevar by_device_type : list[ByDeviceTypeItem] | Nonevar by_device_type_truncated : bool | Nonevar by_geo : list[ByGeoItem] | Nonevar by_geo_truncated : bool | Nonevar by_keyword : list[ByKeywordItem] | Nonevar by_placement : list[ByPlacementItem] | Nonevar by_placement_truncated : bool | Nonevar currency : strvar daily_breakdown : list[DailyBreakdownItem] | Nonevar delivery_status : DeliveryStatus | Nonevar model_configvar pacing_index : float | Nonevar package_id : strvar paused : bool | Nonevar pricing_model : PricingModelvar rate : floatvar spend : Any
Inherited members
class CalibrateContentRequest (**data: Any)-
Expand source code
class CalibrateContentRequest(AdCPBaseModel): artifact: Annotated[artifact_1.Artifact, Field(description='Artifact to evaluate')] idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. 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, ), ] = None standards_id: Annotated[str, Field(description='Standards configuration to calibrate against')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var artifact : Artifactvar idempotency_key : str | Nonevar model_configvar standards_id : str
Inherited members
class CalibrateContentSuccessResponse (**data: Any)-
Expand source code
class CalibrateContentResponse1(AdCPBaseModel): confidence: Annotated[ float | None, Field(description='Model confidence in the verdict (0-1)', ge=0.0, le=1.0) ] = None context: context_1.ContextObject | None = None explanation: Annotated[ str | None, Field(description='Detailed natural language explanation of the decision') ] = None ext: ext_1.ExtensionObject | None = None features: Annotated[ list[Feature] | None, Field(description='Per-feature breakdown with explanations') ] = None verdict: Annotated[ Verdict, Field(description='Overall pass/fail verdict for the content evaluation') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var confidence : float | Nonevar context : ContextObject | Nonevar explanation : str | Nonevar ext : ExtensionObject | Nonevar features : list[Feature] | Nonevar model_configvar verdict : Verdict
Inherited members
class CalibrateContentErrorResponse (**data: Any)-
Expand source code
class CalibrateContentResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class Catalog (**data: Any)-
Expand source code
class Catalog(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_id: Annotated[ str | None, Field( description="Buyer's identifier for this catalog. Required when syncing via sync_catalogs. When used in creatives, references a previously synced catalog on the account." ), ] = None category: Annotated[ str | None, Field( description="Filter catalog to items in this category (e.g., 'beverages/soft-drinks', 'chef-positions')." ), ] = None content_id_type: Annotated[ content_id_type_1.ContentIdType | None, Field( description="Identifier type that the event's content_ids field should be matched against for items in this catalog. For example, 'gtin' means content_ids values are Global Trade Item Numbers, 'sku' means retailer SKUs. Omit when using a custom identifier scheme not listed in the enum." ), ] = None conversion_events: Annotated[ list[event_type.EventType] | None, Field( description="Event types that represent conversions for items in this catalog. Declares what events the platform should attribute to catalog items — e.g., a job catalog converts via submit_application, a product catalog via purchase. The event's content_ids field carries the item IDs that connect back to catalog items. Use content_id_type to declare what identifier type content_ids values represent.", min_length=1, ), ] = None feed_field_mappings: Annotated[ list[catalog_field_mapping.CatalogFieldMapping] | None, Field( description='Declarative normalization rules for external feeds. Maps non-standard feed field names, date formats, price encodings, and image URLs to the AdCP catalog item schema. Applied during sync_catalogs ingestion. Supports field renames, named transforms (date, divide, boolean, split), static literal injection, and assignment of image URLs to typed asset pools.', min_length=1, ), ] = None feed_format: Annotated[ feed_format_1.FeedFormat | None, Field( description='Format of the external feed at url. Required when url points to a non-AdCP feed (e.g., Google Merchant Center XML, Meta Product Catalog). Omit for offering-type catalogs where the feed is native AdCP JSON.' ), ] = None gtins: Annotated[ list[Gtin] | None, Field( description="Filter product-type catalogs by GTIN identifiers for cross-retailer catalog matching. Accepts standard GTIN formats (GTIN-8, UPC-A/GTIN-12, EAN-13/GTIN-13, GTIN-14). Only applicable when type is 'product'.", min_length=1, ), ] = None ids: Annotated[ list[str] | None, Field( description='Filter catalog to specific item IDs. For offering-type catalogs, these are offering_id values. For product-type catalogs, these are SKU identifiers.', min_length=1, ), ] = None items: Annotated[ list[dict[str, Any]] | None, Field( description="Inline catalog data. The item schema depends on the catalog type: Offering objects for 'offering', StoreItem for 'store', HotelItem for 'hotel', FlightItem for 'flight', JobItem for 'job', VehicleItem for 'vehicle', RealEstateItem for 'real_estate', EducationItem for 'education', DestinationItem for 'destination', AppItem for 'app', or freeform objects for 'product', 'inventory', and 'promotion'. Mutually exclusive with url — provide one or the other, not both. Implementations should validate items against the type-specific schema.", min_length=1, ), ] = None name: Annotated[ str | None, Field( description="Human-readable name for this catalog (e.g., 'Summer Products 2025', 'Amsterdam Store Locations')." ), ] = None query: Annotated[ str | None, Field( description="Natural language filter for catalog items (e.g., 'all pasta sauces under $5', 'amsterdam vacancies')." ), ] = None tags: Annotated[ list[str] | None, Field( description='Filter catalog to items with these tags. Tags are matched using OR logic — items matching any tag are included.', min_length=1, ), ] = None type: Annotated[ catalog_type.CatalogType, Field( description="Catalog type. Structural types: 'offering' (AdCP Offering objects), 'product' (ecommerce entries), 'inventory' (stock per location), 'store' (physical locations), 'promotion' (deals and pricing). Vertical types: 'hotel', 'flight', 'job', 'vehicle', 'real_estate', 'education', 'destination', 'app' — each with an industry-specific item schema." ), ] update_frequency: Annotated[ update_frequency_1.UpdateFrequency | None, Field( description='How often the platform should re-fetch the feed from url. Only applicable when url is provided. Platforms may use this as a hint for polling schedules.' ), ] = None url: Annotated[ AnyUrl | None, Field( description="URL to an external catalog feed. The platform fetches and resolves items from this URL. For offering-type catalogs, the feed contains an array of Offering objects. For other types, the feed format is determined by feed_format. When omitted with type 'product', the platform uses its synced copy of the brand's product catalog." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Subclasses
Class variables
var catalog_id : str | Nonevar category : str | Nonevar content_id_type : ContentIdType | Nonevar conversion_events : list[EventType] | Nonevar feed_field_mappings : list[CatalogFieldMapping] | Nonevar feed_format : FeedFormat | Nonevar gtins : list[Gtin] | Nonevar ids : list[str] | Nonevar items : list[dict[str, typing.Any]] | Nonevar model_configvar name : str | Nonevar query : str | Nonevar type : CatalogTypevar update_frequency : UpdateFrequency | Nonevar url : pydantic.networks.AnyUrl | None
class SyncCatalogResult (**data: Any)-
Expand source code
class Catalog(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) action: Annotated[ catalog_action.CatalogAction, Field(description='Action taken for this catalog') ] catalog_id: Annotated[str, Field(description='Catalog ID from the request')] changes: Annotated[ list[str] | None, Field(description="Field names that were modified (only present when action='updated')"), ] = None errors: Annotated[ list[str] | None, Field(description="Validation or processing errors (only present when action='failed')"), ] = None item_count: Annotated[ int | None, Field(description='Total number of items in the catalog after sync', ge=0) ] = None item_issues: Annotated[ list[ItemIssue] | None, Field( description='Per-item issues reported by the platform (rejections, warnings). Only present when the platform performs item-level review.' ), ] = None items_approved: Annotated[ int | None, Field( description='Number of items approved by the platform. Populated when the platform performs item-level review.', ge=0, ), ] = None items_pending: Annotated[ int | None, Field( description='Number of items pending platform review. Common for product catalogs where items must pass content policy checks.', ge=0, ), ] = None items_rejected: Annotated[ int | None, Field( description='Number of items rejected by the platform. Check item_issues for rejection reasons.', ge=0, ), ] = None last_synced_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp of when the most recent sync was accepted by the platform' ), ] = None next_fetch_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp of when the platform will next fetch the feed URL. Only present for URL-based catalogs with update_frequency.' ), ] = None platform_id: Annotated[ str | None, Field(description='Platform-specific ID assigned to the catalog') ] = None warnings: Annotated[ list[str] | None, Field(description='Non-fatal warnings about this catalog') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var action : CatalogActionvar catalog_id : strvar changes : list[str] | Nonevar errors : list[str] | Nonevar item_count : int | Nonevar item_issues : list[ItemIssue] | Nonevar items_approved : int | Nonevar items_pending : int | Nonevar items_rejected : int | Nonevar last_synced_at : pydantic.types.AwareDatetime | Nonevar model_configvar next_fetch_at : pydantic.types.AwareDatetime | Nonevar platform_id : str | Nonevar warnings : list[str] | None
Inherited members
class CatalogAction (*args, **kwds)-
Expand source code
class CatalogAction(Enum): created = 'created' updated = 'updated' unchanged = 'unchanged' failed = 'failed' deleted = 'deleted'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var createdvar deletedvar failedvar unchangedvar updated
class CatalogFieldBinding (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class CatalogFieldBinding(RootModel[ScalarBinding | AssetPoolBinding | CatalogFieldBinding1]): root: Annotated[ ScalarBinding | AssetPoolBinding | CatalogFieldBinding1, Field( description="Maps a format template slot to a catalog item field or typed asset pool. The 'kind' field identifies the binding variant. All bindings are optional — agents can still infer mappings without them.", examples=[ { 'data': {'asset_id': 'headline', 'catalog_field': 'name', 'kind': 'scalar'}, 'description': 'Scalar binding — hotel name to headline slot', }, { 'data': { 'asset_id': 'price_badge', 'catalog_field': 'price.amount', 'kind': 'scalar', }, 'description': 'Scalar binding — nested field (nightly rate)', }, { 'data': { 'asset_group_id': 'images_landscape', 'asset_id': 'hero_image', 'kind': 'asset_pool', }, 'description': 'Asset pool binding — hero image from landscape pool', }, { 'data': { 'asset_group_id': 'images_vertical', 'asset_id': 'snap_background', 'kind': 'asset_pool', }, 'description': 'Asset pool binding — Snap vertical background from vertical pool', }, { 'data': { 'catalog_item': True, 'format_group_id': 'slide', 'kind': 'catalog_group', 'per_item_bindings': [ {'asset_id': 'title', 'catalog_field': 'name', 'kind': 'scalar'}, { 'asset_id': 'price', 'catalog_field': 'price.amount', 'kind': 'scalar', }, { 'asset_group_id': 'images_landscape', 'asset_id': 'image', 'kind': 'asset_pool', }, ], }, 'description': 'Catalog group binding — carousel where each slide is one hotel', }, ], title='Catalog Field Binding', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[ScalarBinding, AssetPoolBinding, CatalogFieldBinding1]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : ScalarBinding | AssetPoolBinding | CatalogFieldBinding1
class CatalogFieldBinding1 (**data: Any)-
Expand source code
class CatalogFieldBinding1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_item: Annotated[ Literal[True], Field( description="Each repetition of the format's repeatable_group maps to one item from the catalog." ), ] ext: ext_1.ExtensionObject | None = None format_group_id: Annotated[ str, Field(description="The asset_group_id of a repeatable_group in the format's assets array."), ] kind: Literal['catalog_group'] per_item_bindings: Annotated[ list[ScalarBinding | AssetPoolBinding] | None, Field( description='Scalar and asset pool bindings that apply within each repetition of the group. Nested catalog_group bindings are not permitted.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalog_item : Literal[True]var ext : ExtensionObject | Nonevar format_group_id : strvar kind : Literal['catalog_group']var model_configvar per_item_bindings : list[ScalarBinding | AssetPoolBinding] | None
class CatalogGroupBinding (**data: Any)-
Expand source code
class CatalogFieldBinding1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_item: Annotated[ Literal[True], Field( description="Each repetition of the format's repeatable_group maps to one item from the catalog." ), ] ext: ext_1.ExtensionObject | None = None format_group_id: Annotated[ str, Field(description="The asset_group_id of a repeatable_group in the format's assets array."), ] kind: Literal['catalog_group'] per_item_bindings: Annotated[ list[ScalarBinding | AssetPoolBinding] | None, Field( description='Scalar and asset pool bindings that apply within each repetition of the group. Nested catalog_group bindings are not permitted.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalog_item : Literal[True]var ext : ExtensionObject | Nonevar format_group_id : strvar kind : Literal['catalog_group']var model_configvar per_item_bindings : list[ScalarBinding | AssetPoolBinding] | None
Inherited members
class CatalogFieldMapping (**data: Any)-
Expand source code
class CatalogFieldMapping(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) asset_group_id: Annotated[ str | None, Field( description="Places the feed field value (a URL) into a typed asset pool on the catalog item's assets array. The value is wrapped as an image or video asset in a group with this ID. Use standard group IDs: 'images_landscape', 'images_vertical', 'images_square', 'logo', 'video'. Mutually exclusive with catalog_field." ), ] = None by: Annotated[ float | None, Field( description="For transform 'divide': the divisor to apply (e.g., 100 to convert integer cents to decimal dollars).", gt=0.0, ), ] = None catalog_field: Annotated[ str | None, Field( description="Target field on the catalog item schema, using dot notation for nested fields (e.g., 'name', 'price.amount', 'location.city'). Mutually exclusive with asset_group_id." ), ] = None default: Annotated[ Any | None, Field( description='Fallback value to use when feed_field is absent, null, or empty. Applied after any transform would have been applied. Allows optional feed fields to have a guaranteed baseline value.' ), ] = None ext: ext_1.ExtensionObject | None = None feed_field: Annotated[ str | None, Field( description='Field name in the external feed record. Omit when injecting a static literal value (use the value property instead).' ), ] = None format: Annotated[ str | None, Field( description="For transform 'date': the input date format string (e.g., 'YYYYMMDD', 'MM/DD/YYYY', 'DD-MM-YYYY'). Output is always ISO 8601 (e.g., '2025-03-01'). Uses Unicode date pattern tokens." ), ] = None separator: Annotated[ str | None, Field( description="For transform 'split': the separator character or string to split on. Defaults to ','." ), ] = ',' timezone: Annotated[ str | None, Field( description="For transform 'date': the timezone of the input value. IANA timezone identifier (e.g., 'UTC', 'America/New_York', 'Europe/Amsterdam'). Defaults to UTC when omitted." ), ] = None transform: Annotated[ Transform | None, Field( description='Named transform to apply to the feed field value before writing to the catalog schema. See transform-specific parameters (format, timezone, by, separator).' ), ] = None value: Annotated[ Any | None, Field( description='Static literal value to inject into catalog_field for every item, regardless of what the feed contains. Mutually exclusive with feed_field. Useful for fields the feed omits (e.g., currency when price is always USD, or a constant category value).' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var asset_group_id : str | Nonevar by : float | Nonevar catalog_field : str | Nonevar default : typing.Any | Nonevar ext : ExtensionObject | Nonevar feed_field : str | Nonevar format : str | Nonevar model_configvar separator : str | Nonevar timezone : str | Nonevar transform : Transform | Nonevar value : typing.Any | None
Inherited members
class CatalogItemStatus (*args, **kwds)-
Expand source code
class CatalogItemStatus(Enum): approved = 'approved' pending = 'pending' rejected = 'rejected' warning = 'warning'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var approvedvar pendingvar rejectedvar warning
class CatalogRequirements (**data: Any)-
Expand source code
class CatalogRequirements(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_type: Annotated[ catalog_type_1.CatalogType, Field(description='The catalog type this requirement applies to'), ] feed_formats: Annotated[ list[feed_format.FeedFormat] | None, Field( description='Accepted feed formats for this catalog type. When specified, the synced catalog must use one of these formats. When omitted, any format is accepted.', min_length=1, ), ] = None field_bindings: Annotated[ list[catalog_field_binding.CatalogFieldBinding] | None, Field( description='Explicit mappings from format template slots to catalog item fields or typed asset pools. Optional — creative agents can infer mappings without them, but bindings make the relationship self-describing and enable validation. Covers scalar fields (asset_id → catalog_field), asset pools (asset_id → asset_group_id on the catalog item), and repeatable groups that iterate over catalog items.', min_length=1, ), ] = None max_items: Annotated[ int | None, Field( description='Maximum number of items the format can render. Items beyond this limit are ignored. Useful for fixed-slot layouts (e.g., a 3-product card) or feed-size constraints.', ge=1, ), ] = None min_items: Annotated[ int | None, Field( description='Minimum number of items the catalog must contain for this format to render properly (e.g., a carousel might require at least 3 products)', ge=1, ), ] = None offering_asset_constraints: Annotated[ list[offering_asset_constraint.OfferingAssetConstraint] | None, Field( description="Per-item creative asset requirements. Declares what asset groups (headlines, images, videos) each catalog item must provide in its assets array, along with count bounds and per-asset technical constraints. Applicable to 'offering' and all vertical catalog types (hotel, flight, job, etc.) whose items carry typed assets.", min_length=1, ), ] = None required: Annotated[ bool | None, Field( description='Whether this catalog type must be present. When true, creatives using this format must reference a synced catalog of this type.' ), ] = True required_fields: Annotated[ list[str] | None, Field( description="Fields that must be present and non-empty on every item in the catalog. Field names are catalog-type-specific (e.g., 'title', 'price', 'image_url' for product catalogs; 'store_id', 'quantity' for inventory feeds).", min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalog_type : CatalogTypevar feed_formats : list[FeedFormat] | Nonevar field_bindings : list[CatalogFieldBinding] | Nonevar max_items : int | Nonevar min_items : int | Nonevar model_configvar offering_asset_constraints : list[OfferingAssetConstraint] | Nonevar required : bool | Nonevar required_fields : list[str] | None
Inherited members
class CatalogType (*args, **kwds)-
Expand source code
class CatalogType(Enum): offering = 'offering' product = 'product' inventory = 'inventory' store = 'store' promotion = 'promotion' hotel = 'hotel' flight = 'flight' job = 'job' vehicle = 'vehicle' real_estate = 'real_estate' education = 'education' destination = 'destination' app = 'app'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var appvar destinationvar educationvar flightvar hotelvar inventoryvar jobvar offeringvar productvar promotionvar real_estatevar storevar vehicle
class CheckGovernanceRequest (**data: Any)-
Expand source code
class CheckGovernanceRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) caller: Annotated[AnyUrl, Field(description='URL of the agent making the request.')] delivery_metrics: Annotated[ DeliveryMetrics | None, Field( description="Actual delivery performance data. MUST be present for 'delivery' phase. The governance agent compares these metrics against the planned delivery to detect drift." ), ] = None governance_context: Annotated[ str | None, Field( description='Opaque governance context from a prior check_governance response. Pass this on subsequent checks for the same media buy so the governance agent can maintain continuity across the lifecycle. Issued by the governance agent, never interpreted by callers.', max_length=4096, min_length=1, pattern='^[\\x20-\\x7E]+$', ), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description='Per-buy invoice recipient from create_media_buy or update_media_buy. MUST be present when the tool payload includes invoice_recipient, so the governance agent can validate billing changes.' ), ] = None media_buy_id: Annotated[ str | None, Field( description="The seller's identifier for the media buy. Present on execution checks (seller). The governance agent uses the presence of media_buy_id+planned_delivery to identify an execution check." ), ] = None modification_summary: Annotated[ str | None, Field( description="Human-readable summary of what changed. SHOULD be present for 'modification' phase.", max_length=1000, ), ] = None payload: Annotated[ dict[str, Any] | None, Field( description='The full tool arguments as they would be sent to the seller. Present on intent checks. The governance agent can inspect any field to validate against the plan.' ), ] = None phase: Annotated[ governance_phase.GovernancePhase | None, Field( description="The phase of the media buy lifecycle. 'purchase': initial create_media_buy. 'modification': update_media_buy. 'delivery': periodic delivery reporting. Defaults to 'purchase' if omitted." ), ] = governance_phase.GovernancePhase.purchase plan_id: Annotated[str, Field(description='Campaign governance plan identifier.')] planned_delivery: Annotated[ planned_delivery_1.PlannedDelivery | None, Field(description='What the seller will actually deliver. Present on execution checks.'), ] = None tool: Annotated[ str | None, Field( description="The AdCP tool being checked (e.g., 'create_media_buy', 'get_products'). Present on intent checks (orchestrator). The governance agent uses the presence of tool+payload to identify an intent check." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var caller : pydantic.networks.AnyUrlvar delivery_metrics : DeliveryMetrics | Nonevar governance_context : str | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : str | Nonevar model_configvar modification_summary : str | Nonevar payload : dict[str, typing.Any] | Nonevar phase : GovernancePhase | Nonevar plan_id : strvar planned_delivery : PlannedDelivery | Nonevar tool : str | None
Inherited members
class CheckGovernanceResponse (**data: Any)-
Expand source code
class CheckGovernanceResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) categories_evaluated: Annotated[ list[str] | None, Field(description='Governance categories evaluated during this check.') ] = None check_id: Annotated[ str, Field( description='Unique identifier for this governance check record. Use in report_plan_outcome to link outcomes to the check that authorized them.' ), ] conditions: Annotated[ list[Condition] | None, Field( description="Present when status is 'conditions'. Specific adjustments the caller must make. After applying conditions, the caller MUST re-call check_governance with the adjusted parameters before proceeding." ), ] = None expires_at: Annotated[ AwareDatetime | None, Field( description="When this approval expires. Present when status is 'approved' or 'conditions'. The caller must act before this time or re-call check_governance. A lapsed approval is no approval." ), ] = None explanation: Annotated[ str, Field(description='Human-readable explanation of the governance decision.') ] findings: Annotated[ list[Finding] | None, Field( description="Specific issues found during the governance check. Present when status is 'denied' or 'conditions'. MAY also be present on 'approved' for informational findings (e.g., budget approaching limit)." ), ] = None governance_context: Annotated[ str | None, Field( description="Opaque governance context for this media buy. The buyer MUST attach this to the protocol envelope when sending the media buy to the seller. The seller MUST persist it and include it on all subsequent check_governance calls for this media buy's lifecycle. Only the issuing governance agent interprets this value.", max_length=4096, min_length=1, pattern='^[\\x20-\\x7E]+$', ), ] = None next_check: Annotated[ AwareDatetime | None, Field( description='When the seller should next call check_governance with delivery metrics. Present when the governance agent expects ongoing delivery reporting.' ), ] = None plan_id: Annotated[str, Field(description='Echoed from request.')] policies_evaluated: Annotated[ list[str] | None, Field(description='Registry policy IDs evaluated during this check.') ] = None status: Annotated[ Status, Field( description="Governance decision. 'approved': proceed as planned. 'denied': do not proceed. 'conditions': approved if the caller accepts the listed conditions, then re-calls check_governance with the adjusted parameters." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var categories_evaluated : list[str] | Nonevar check_id : strvar conditions : list[Condition] | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar explanation : strvar findings : list[Finding] | Nonevar governance_context : str | Nonevar model_configvar next_check : pydantic.types.AwareDatetime | Nonevar plan_id : strvar policies_evaluated : list[str] | Nonevar status : Status
Inherited members
class CoBrandingRequirement (*args, **kwds)-
Expand source code
class CoBrandingRequirement(Enum): required = 'required' optional = 'optional' none = 'none'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var nonevar optionalvar required
class CoBranding (*args, **kwds)-
Expand source code
class CoBrandingRequirement(Enum): required = 'required' optional = 'optional' none = 'none'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var nonevar optionalvar required
class Colors (**data: Any)-
Expand source code
class Colors(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accent: Accent | Accent1 | None = None background: Background | Background2 | None = None primary: Primary | Primary1 | None = None secondary: Secondary | Secondary1 | None = None text: Text | Text1 | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accent : Accent | Accent1 | Nonevar background : Background | Background2 | Nonevar model_configvar primary : Primary | Primary1 | Nonevar secondary : Secondary | Secondary1 | Nonevar text : Text | Text1 | None
Inherited members
class ComplyListScenariosRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None scenario: Literal['list_scenarios']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar scenario : Literal['list_scenarios']
Inherited members
class ComplyForceCreativeStatusRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params scenario: Literal['force_creative_status']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Paramsvar scenario : Literal['force_creative_status']
Inherited members
class ComplyForceAccountStatusRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params1 scenario: Literal['force_account_status']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Params1var scenario : Literal['force_account_status']
Inherited members
class ComplyForceMediaBuyStatusRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest4(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params2 scenario: Literal['force_media_buy_status']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Params2var scenario : Literal['force_media_buy_status']
Inherited members
class ComplyForceSessionStatusRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest5(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params3 scenario: Literal['force_session_status']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Params3var scenario : Literal['force_session_status']
Inherited members
class ComplySimulateDeliveryRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest6(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params4 scenario: Literal['simulate_delivery']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Params4var scenario : Literal['simulate_delivery']
Inherited members
class ComplySimulateBudgetSpendRequest (**data: Any)-
Expand source code
class ComplyTestControllerRequest7(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None params: Params5 | Params6 scenario: Literal['simulate_budget_spend']Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar params : Params5 | Params6var scenario : Literal['simulate_budget_spend']
Inherited members
class ComplyListScenariosResponse (**data: Any)-
Expand source code
class ComplyTestControllerResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None scenarios: Annotated[list[Scenario], Field(description='Scenarios this seller has implemented')] success: Literal[True]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar scenarios : list[Scenario]var success : Literal[True]
Inherited members
class ComplyStateTransitionResponse (**data: Any)-
Expand source code
class ComplyTestControllerResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None current_state: Annotated[str, Field(description='State after this transition')] ext: ext_1.ExtensionObject | None = None message: Annotated[ str | None, Field(description='Human-readable description of the transition') ] = None previous_state: Annotated[str, Field(description='State before this transition')] success: Literal[True]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar current_state : strvar ext : ExtensionObject | Nonevar message : str | Nonevar model_configvar previous_state : strvar success : Literal[True]
Inherited members
class ComplySimulationResponse (**data: Any)-
Expand source code
class ComplyTestControllerResponse3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None cumulative: Annotated[ dict[str, Any] | None, Field(description='Running totals across all simulation calls (simulate_delivery only)'), ] = None ext: ext_1.ExtensionObject | None = None message: str | None = None simulated: Annotated[ dict[str, Any], Field(description='Values injected or applied by this call. Shape depends on scenario.'), ] success: Literal[True]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar cumulative : dict[str, typing.Any] | Nonevar ext : ExtensionObject | Nonevar message : str | Nonevar model_configvar simulated : dict[str, typing.Any]var success : Literal[True]
Inherited members
class ComplyErrorResponse (**data: Any)-
Expand source code
class ComplyTestControllerResponse4(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None current_state: Annotated[ str | None, Field(description='Current state of the entity, or null if not found') ] = None error: Annotated[Error, Field(description='Structured error code')] error_detail: Annotated[ str | None, Field(description='Human-readable explanation of the failure') ] = None ext: ext_1.ExtensionObject | None = None success: Literal[False]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar current_state : str | Nonevar error : Errorvar error_detail : str | Nonevar ext : ExtensionObject | Nonevar model_configvar success : Literal[False]
Inherited members
class ConsentBasis (*args, **kwds)-
Expand source code
class ConsentBasis(Enum): consent = 'consent' legitimate_interest = 'legitimate_interest' contract = 'contract' legal_obligation = 'legal_obligation'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var consentvar contractvar legal_obligationvar legitimate_interest
class Contact (**data: Any)-
Expand source code
class Contact(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) domain: Annotated[ str | None, Field( description='Primary domain of the entity managing this file', pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] = None email: Annotated[ EmailStr | None, Field( description='Contact email for questions or issues with this authorization file', max_length=255, min_length=1, ), ] = None name: Annotated[ str, Field( description="Name of the entity managing this file (e.g., 'Meta Advertising Operations', 'Clear Channel Digital')", max_length=255, min_length=1, ), ] privacy_policy_url: Annotated[ AnyUrl | None, Field( description="URL to the entity's privacy policy. Used for consumer consent flows when interacting with this sales agent." ), ] = None seller_id: Annotated[ str | None, Field( description='Seller ID from IAB Tech Lab sellers.json (if applicable)', max_length=255, min_length=1, ), ] = None tag_id: Annotated[ str | None, Field( description='TAG Certified Against Fraud ID for verification (if applicable)', max_length=100, min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var domain : str | Nonevar email : pydantic.networks.EmailStr | Nonevar model_configvar name : strvar privacy_policy_url : pydantic.networks.AnyUrl | Nonevar seller_id : str | Nonevar tag_id : str | None
Inherited members
class ContentIdType (*args, **kwds)-
Expand source code
class ContentIdType(Enum): sku = 'sku' gtin = 'gtin' offering_id = 'offering_id' job_id = 'job_id' hotel_id = 'hotel_id' flight_id = 'flight_id' vehicle_id = 'vehicle_id' listing_id = 'listing_id' store_id = 'store_id' program_id = 'program_id' destination_id = 'destination_id' app_id = 'app_id'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var app_idvar destination_idvar flight_idvar gtinvar hotel_idvar job_idvar listing_idvar offering_idvar program_idvar skuvar store_idvar vehicle_id
class ContentStandards (**data: Any)-
Expand source code
class ContentStandards(AdCPBaseModel): calibration_exemplars: Annotated[ CalibrationExemplars | None, Field( description='Training/test set to calibrate policy interpretation. Provides concrete examples of pass/fail decisions.' ), ] = None channels_any: Annotated[ list[channels.MediaChannel] | None, Field( description='Advertising channels. Standards apply to ANY of the listed channels (OR logic).', min_length=1, ), ] = None countries_all: Annotated[ list[str] | None, Field( description='ISO 3166-1 alpha-2 country codes. Standards apply in ALL listed countries (AND logic).', min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = None languages_any: Annotated[ list[str] | None, Field( description="BCP 47 language tags (e.g., 'en', 'de', 'fr'). Standards apply to content in ANY of these languages (OR logic). Content in unlisted languages is not covered by these standards.", min_length=1, ), ] = None name: Annotated[ str | None, Field(description='Human-readable name for this standards configuration') ] = None policy: Annotated[ str | None, Field( description='Natural language policy describing acceptable and unacceptable content contexts. Used by LLMs and human reviewers to make judgments.' ), ] = None pricing_options: Annotated[ list[pricing_option.PricingOption] | None, Field( description='Pricing options for this content standards service. The buyer passes the selected pricing_option_id in report_usage for billing verification.', min_length=1, ), ] = None standards_id: Annotated[ str, Field(description='Unique identifier for this standards configuration') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Subclasses
Class variables
var calibration_exemplars : CalibrationExemplars | Nonevar channels_any : list[MediaChannel] | Nonevar countries_all : list[str] | Nonevar ext : ExtensionObject | Nonevar languages_any : list[str] | Nonevar model_configvar name : str | Nonevar policy : str | Nonevar pricing_options : list[PricingOption] | Nonevar standards_id : str
Inherited members
class ContextMatchRequest (**data: Any)-
Expand source code
class ContextMatchRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) field_schema: Annotated[ AnyUrl | None, Field( alias='$schema', description='Optional schema URI for validation. Ignored at runtime.' ), ] = None artifact: Annotated[ artifact_1.Artifact | None, Field( description='Full content artifact adjacent to this ad opportunity. Same schema used for content standards evaluation. The publisher sends the artifact when they want the buyer to evaluate the full content. Contractual protections govern buyer use. TEE deployment upgrades contractual trust to cryptographic verification. Publishers MUST NOT include asset access credentials (bearer tokens, service accounts) — the router fans out to multiple buyer agents. For secured assets, use signed URLs with short expiry. Routers MUST strip access fields from artifacts before forwarding.' ), ] = None artifact_refs: Annotated[ list[ArtifactRef] | None, Field( description='Public content references adjacent to this ad opportunity. Each artifact identifies content via a public identifier the buyer can resolve independently — no private registry sync required.', max_length=20, min_length=1, ), ] = None context_signals: Annotated[ ContextSignals | None, Field( description='Pre-computed classifier outputs for the content environment. Use when the publisher wants to provide classified context without sharing content or public references. Can supplement artifact_refs (e.g., URL + pre-classified topics) or replace them entirely (e.g., ephemeral conversation turns). Raw content MUST NOT be included — only classified outputs. The publisher is the classifier boundary.' ), ] = None geo: Annotated[ Geo | None, Field( description='Coarse geographic location of the viewer. Publisher controls granularity — country is sufficient for regulatory compliance and volume filtering, region or metro helps with campaign targeting and valuation. Coarsened to prevent user identification: no postcode, no coordinates. All fields optional.' ), ] = None package_ids: Annotated[ list[str] | None, Field( description='Restrict evaluation to specific packages. When omitted, the provider evaluates all eligible packages for this placement (the common case). MUST NOT vary by user — the same package_ids must be sent for every user on a given placement. User-dependent filtering leaks identity into the context path.', max_length=500, min_length=1, ), ] = None placement_id: Annotated[ str, Field( description="Placement identifier from the publisher's placement registry in adagents.json. Identifies where on the property this ad opportunity exists. One placement per request." ), ] property_id: Annotated[ property_id_1.PropertyId | None, Field( description="Publisher's human-readable property slug (e.g., 'cnn_homepage'). Optional when property_rid is present. Useful for logging and debugging." ), ] = None property_rid: Annotated[ UUID, Field( description='Property catalog UUID (UUID v7). Globally unique, stable identifier assigned by the property catalog. The primary key for TMP matching and property list targeting.' ), ] property_type: Annotated[ property_type_1.PropertyType, Field(description='Type of the publisher property') ] protocol_version: Annotated[ str | None, Field( description='TMP protocol version. Allows receivers to handle semantic differences across versions.' ), ] = '1.0' request_id: Annotated[ str, Field( description='Unique request identifier. MUST NOT correlate with any identity match request_id.' ), ] type: Annotated[ Literal['context_match_request'], Field(description='Message type discriminator for deserialization.'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var artifact : Artifact | Nonevar artifact_refs : list[ArtifactRef] | Nonevar context_signals : ContextSignals | Nonevar field_schema : pydantic.networks.AnyUrl | Nonevar geo : Geo | Nonevar model_configvar package_ids : list[str] | Nonevar placement_id : strvar property_id : PropertyId | Nonevar property_rid : uuid.UUIDvar property_type : PropertyTypevar protocol_version : str | Nonevar request_id : strvar type : Literal['context_match_request']
Inherited members
class ContextMatchResponse (**data: Any)-
Expand source code
class ContextMatchResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) cache_ttl: Annotated[ int | None, Field( description='Optional override for the default 5-minute cache TTL, in seconds. When present, the router MUST use this value instead of its default. Set to 0 to disable caching (e.g., when targeting configuration has just changed).', ge=0, le=86400, ), ] = None offers: Annotated[ list[offer.Offer], Field( description='Offers from the buyer, one per activated package. An empty array means no packages matched. For simple activation, each offer has just package_id. For richer responses, offers include brand, price, summary, and creative manifest.' ), ] request_id: Annotated[ str, Field(description='Echoed request identifier from the context match request') ] signals: Annotated[ Signals | None, Field( description='Response-level targeting signals for ad server pass-through. In the GAM case, these carry the key-value pairs that trigger line items. Not per-offer — applies to the response as a whole.' ), ] = None type: Annotated[ Literal['context_match_response'], Field(description='Message type discriminator for deserialization.'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var cache_ttl : int | Nonevar model_configvar offers : list[Offer]var request_id : strvar signals : Signals | Nonevar type : Literal['context_match_response']
Inherited members
class ContextObject (**data: Any)-
Expand source code
class ContextObject(AdCPBaseModel): model_config = ConfigDict( extra='allow', )Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class Country (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class Country(RootModel[str]): root: Annotated[str, Field(pattern='^[A-Z]{2}$')]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : str
class CpaPricingOption (**data: Any)-
Expand source code
class CpaPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] custom_event_name: Annotated[ str | None, Field( description="Name of the custom event when event_type is 'custom'. Required when event_type is 'custom', ignored otherwise." ), ] = None eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None event_source_id: Annotated[ str | None, Field( description='When present, only events from this specific event source count toward billing. Allows different CPA rates for different sources (e.g., online vs in-store purchases). Must match an event source configured via sync_event_sources.' ), ] = None event_type: Annotated[ event_type_1.EventType, Field( description='The conversion event type that triggers billing (e.g., purchase, lead, app_install)' ), ] fixed_price: Annotated[ float, Field(description='Fixed price per acquisition in the specified currency', gt=0.0) ] min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None pricing_model: Annotated[ Literal['cpa'], Field(description='Cost per acquisition (conversion event)') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar custom_event_name : str | Nonevar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar event_source_id : str | Nonevar event_type : EventTypevar fixed_price : floatvar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar pricing_model : Literal['cpa']var pricing_option_id : str
Inherited members
class CpcPricingOption (**data: Any)-
Expand source code
class CpcPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per click. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpc'], Field(description='Cost per click')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpc']var pricing_option_id : str
Inherited members
class CpcvPricingOption (**data: Any)-
Expand source code
class CpcvPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per completed view. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['cpcv'], Field(description='Cost per completed view (100% completion)') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpcv']var pricing_option_id : str
Inherited members
class CpmPricingOption (**data: Any)-
Expand source code
class CpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpm']var pricing_option_id : str
class CpmAuctionPricingOption (**data: Any)-
Expand source code
class CpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpm']var pricing_option_id : str
class CpmFixedRatePricingOption (**data: Any)-
Expand source code
class CpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpm']var pricing_option_id : str
Inherited members
class CppPricingOption (**data: Any)-
Expand source code
class CppPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per rating point. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None parameters: Annotated[ Parameters, Field(description='CPP-specific parameters for demographic targeting') ] price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpp'], Field(description='Cost per Gross Rating Point')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpp']var pricing_option_id : str
Inherited members
class CpvPricingOption (**data: Any)-
Expand source code
class CpvPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per view. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None parameters: Annotated[ Parameters, Field(description='CPV-specific parameters defining the view threshold') ] price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[Literal['cpv'], Field(description='Cost per view at threshold')] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['cpv']var pricing_option_id : str
Inherited members
class CreateContentStandardsRequest (**data: Any)-
Expand source code
class CreateContentStandardsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) calibration_exemplars: Annotated[ CalibrationExemplars | None, Field( description='Training/test set to calibrate policy interpretation. Use URL references for pages to be fetched and analyzed, or full artifacts for pre-extracted content.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate content standards creation on 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, ), ] = None policy: Annotated[ str, Field( description='Natural language policy describing acceptable and unacceptable content contexts. Used by LLMs and human reviewers to make judgments. Optional when registry_policy_ids is provided.' ), ] registry_policy_ids: Annotated[ list[str] | None, Field( description="Registry policy IDs to use as the evaluation basis for this content standard. When provided, the agent resolves policies from the registry and uses their policy text and exemplars as the evaluation criteria. The 'policy' field becomes optional when registry_policy_ids is provided." ), ] = None scope: Annotated[Scope, Field(description='Where this standards configuration applies')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var calibration_exemplars : CalibrationExemplars | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar policy : strvar registry_policy_ids : list[str] | Nonevar scope : Scope
Inherited members
class CreateContentStandardsSuccessResponse (**data: Any)-
Expand source code
class CreateContentStandardsResponse1(AdCPBaseModel): context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None standards_id: Annotated[ str, Field(description='Unique identifier for the created standards configuration') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar standards_id : str
Inherited members
class CreateContentStandardsErrorResponse (**data: Any)-
Expand source code
class CreateContentStandardsResponse2(AdCPBaseModel): conflicting_standards_id: Annotated[ str | None, Field( description='If the error is a scope conflict, the ID of the existing standards that conflict' ), ] = None context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var conflicting_standards_id : str | Nonevar context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class CreateMediaBuyRequest (**data: Any)-
Expand source code
class CreateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field( description='Account to bill for this media buy. Pass a natural key (brand, operator, optional sandbox) or a seller-assigned account_id from list_accounts.' ), ] advertiser_industry: Annotated[ advertiser_industry_1.AdvertiserIndustry | None, Field( description="Industry classification for this specific campaign. A brand may operate across multiple industries (brand.json industries field), but each media buy targets one. For example, a consumer health company running a wellness campaign sends 'healthcare.wellness', not 'cpg'. Sellers map this to platform-native codes (e.g., Spotify ADV categories, LinkedIn industry IDs). When omitted, sellers may infer from the brand manifest's industries field." ), ] = None artifact_webhook: Annotated[ ArtifactWebhook | None, Field( description='Optional webhook configuration for content artifact delivery. Used by governance agents to validate content adjacency. Seller pushes artifacts to this endpoint; orchestrator forwards to governance agent for validation.' ), ] = None brand: Annotated[ brand_ref.BrandReference, Field( description='Brand reference for this media buy. Resolved to full brand identity at execution time from brand.json or the registry.' ), ] context: context_1.ContextObject | None = None end_time: Annotated[ AwareDatetime, Field(description='Campaign end date/time in ISO 8601 format') ] ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. If a request with the same idempotency_key and account has already been processed, the seller returns the existing media buy rather than creating a duplicate. 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, ), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description="Override the account's default billing entity for this specific buy. When provided, the seller invoices this entity instead. The seller MUST validate the invoice recipient is authorized for this account. When governance_agents are configured, the seller MUST include invoice_recipient in the check_governance request." ), ] = None io_acceptance: Annotated[ IoAcceptance | None, Field( description="Acceptance of an insertion order from a committed proposal. Required when the proposal's insertion_order has requires_signature: true. References the io_id from the proposal's insertion_order." ), ] = None packages: Annotated[ list[package_request.PackageRequest] | None, Field( description="Array of package configurations. Required when not using proposal_id. When executing a proposal, this can be omitted and packages will be derived from the proposal's allocations.", min_length=1, ), ] = None plan_id: Annotated[ str | None, Field( description='Campaign governance plan identifier. Required when the account has governance_agents. The seller includes this in the committed check_governance request so the governance agent can validate against the correct plan.' ), ] = None po_number: Annotated[str | None, Field(description='Purchase order number for tracking')] = None proposal_id: Annotated[ str | None, Field( description="ID of a proposal from get_products to execute. When provided with total_budget, the publisher converts the proposal's allocation percentages into packages automatically. Alternative to providing packages array." ), ] = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async task status notifications. Publisher will send webhooks when status changes (working, input-required, completed, failed). The client generates an operation_id and embeds it in the URL before sending — the publisher echoes it back in webhook payloads for correlation.' ), ] = None reporting_webhook: Annotated[ reporting_webhook_1.ReportingWebhook | None, Field(description='Optional webhook configuration for automated reporting delivery'), ] = None start_time: start_timing.StartTiming total_budget: Annotated[ TotalBudget | None, Field( description="Total budget for the media buy when executing a proposal. The publisher applies the proposal's allocation percentages to this amount to derive package budgets." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar advertiser_industry : AdvertiserIndustry | Nonevar artifact_webhook : ArtifactWebhook | Nonevar brand : BrandReferencevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetimevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar invoice_recipient : BusinessEntity | Nonevar io_acceptance : IoAcceptance | Nonevar model_configvar packages : list[PackageRequest] | Nonevar plan_id : str | Nonevar po_number : str | Nonevar proposal_id : str | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar start_time : StartTimingvar total_budget : TotalBudget | None
Inherited members
class CreateMediaBuySuccessResponse (**data: Any)-
Expand source code
class CreateMediaBuyResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_1.Account | None, Field( description='Account billed for this media buy. Includes advertiser, billing proxy (if any), and rate card applied.' ), ] = None confirmed_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when this media buy was confirmed by the seller. A successful create_media_buy response constitutes order confirmation.' ), ] = None context: context_1.ContextObject | None = None creative_deadline: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp for creative upload deadline') ] = None ext: ext_1.ExtensionObject | None = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description='Per-buy invoice recipient, echoed from the request when provided. Confirms the seller accepted the billing override. Bank details are omitted (write-only).' ), ] = None media_buy_id: Annotated[ str, Field(description="Seller's unique identifier for the created media buy") ] packages: Annotated[ list[package.Package], Field(description='Array of created packages with complete state information'), ] planned_delivery: Annotated[ planned_delivery_1.PlannedDelivery | None, Field( description="The seller's interpreted delivery parameters. Describes what the seller will actually run -- geo, channels, flight dates, frequency caps, and budget. Present when the account has governance_agents or when the seller chooses to provide delivery transparency." ), ] = None revision: Annotated[ int | None, Field( description='Initial revision number for this media buy. Use in subsequent update_media_buy requests for optimistic concurrency.', ge=1, ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None status: Annotated[ media_buy_status.MediaBuyStatus | None, Field( description="Initial media buy status. Either 'active' (immediate activation) or 'pending_activation' (awaiting platform setup)." ), ] = None valid_actions: Annotated[ list[ValidAction] | None, Field( description='Actions the buyer can perform on this media buy after creation. Saves a round-trip to get_media_buys.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : Account | Nonevar confirmed_at : pydantic.types.AwareDatetime | Nonevar context : ContextObject | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar packages : list[Package]var planned_delivery : PlannedDelivery | Nonevar revision : int | Nonevar sandbox : bool | Nonevar status : MediaBuyStatus | Nonevar valid_actions : list[ValidAction] | None
Inherited members
class CreateMediaBuyErrorResponse (**data: Any)-
Expand source code
class CreateMediaBuyResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field(description='Array of errors explaining why the operation failed', min_length=1), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class CreatePropertyListRequest (**data: Any)-
Expand source code
class CreatePropertyListRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) base_properties: Annotated[ list[base_property_source.BasePropertySource] | None, Field( description="Array of property sources to evaluate. Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers). If omitted, queries the agent's entire property database.", min_length=1, ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference. When provided, the agent automatically applies appropriate rules based on brand characteristics (industry, target_audience, etc.). Resolved at execution time.' ), ] = None context: context_1.ContextObject | None = None description: Annotated[str | None, Field(description="Description of the list's purpose")] = ( None ) ext: ext_1.ExtensionObject | None = None filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Dynamic filters to apply when resolving the list'), ] = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate property list creation on 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, ), ] = None name: Annotated[str, Field(description='Human-readable name for the list')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var base_properties : list[BasePropertySource] | Nonevar brand : BrandReference | Nonevar context : ContextObject | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar filters : PropertyListFilters | Nonevar idempotency_key : str | Nonevar model_configvar name : str
Inherited members
class CreatePropertyListResponse (**data: Any)-
Expand source code
class CreatePropertyListResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) auth_token: Annotated[ str, Field( description='Token that can be shared with sellers to authorize fetching this list. Store this - it is only returned at creation time.' ), ] ext: ext_1.ExtensionObject | None = None list: Annotated[property_list.PropertyList, Field(description='The created property list')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var auth_token : strvar ext : ExtensionObject | Nonevar list : PropertyListvar model_config
Inherited members
class Creative (**data: Any)-
Expand source code
class Creative(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) creative_id: Annotated[str, Field(description='Creative identifier')] format_id: Annotated[ format_id_1.FormatId | None, Field(description='Format of this creative') ] = None media_buy_id: Annotated[ str | None, Field( description="Publisher's media buy identifier for this creative. Present when the request spanned multiple media buys, so the buyer can correlate each creative to its media buy." ), ] = None totals: Annotated[ delivery_metrics.DeliveryMetrics | None, Field(description='Aggregate delivery metrics across all variants of this creative'), ] = None variant_count: Annotated[ int | None, Field( description='Total number of variants for this creative. When max_variants was specified in the request, this may exceed the number of items in the variants array.', ge=0, ), ] = None variants: Annotated[ list[creative_variant.CreativeVariant], Field( description='Variant-level delivery breakdown. Each variant includes the rendered manifest and delivery metrics. For standard creatives, contains a single variant. For asset group optimization, one per combination. For generative creative, one per generated execution. Empty when a creative has no variants yet.' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var creative_id : strvar format_id : FormatId | Nonevar media_buy_id : str | Nonevar model_configvar totals : DeliveryMetrics | Nonevar variant_count : int | Nonevar variants : list[CreativeVariant]
class SyncCreativeResult (**data: Any)-
Expand source code
class Creative(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_1.Account | None, Field(description='Account that owns this creative') ] = None action: Annotated[ creative_action.CreativeAction, Field(description='Action taken for this creative') ] assigned_to: Annotated[ list[str] | None, Field( description='Package IDs this creative was successfully assigned to (only present when assignments were requested)' ), ] = None assignment_errors: Annotated[ dict[Annotated[str, StringConstraints(pattern=r'^[a-zA-Z0-9_-]+$')], str] | None, Field( description='Assignment errors by package ID (only present when assignment failures occurred)' ), ] = None changes: Annotated[ list[str] | None, Field(description="Field names that were modified (only present when action='updated')"), ] = None creative_id: Annotated[str, Field(description='Creative ID from the request')] errors: Annotated[ list[str] | None, Field(description="Validation or processing errors (only present when action='failed')"), ] = None expires_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when preview link expires (only present when preview_url exists)' ), ] = None platform_id: Annotated[ str | None, Field(description='Platform-specific ID assigned to the creative') ] = None preview_url: Annotated[ AnyUrl | None, Field( description='Preview URL for generative creatives (only present for generative formats)' ), ] = None warnings: Annotated[ list[str] | None, Field(description='Non-fatal warnings about this creative') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : Account | Nonevar action : CreativeActionvar assigned_to : list[str] | Nonevar assignment_errors : dict[str, str] | Nonevar changes : list[str] | Nonevar creative_id : strvar errors : list[str] | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar model_configvar platform_id : str | Nonevar preview_url : pydantic.networks.AnyUrl | Nonevar warnings : list[str] | None
Inherited members
class CreativeAction (*args, **kwds)-
Expand source code
class CreativeAction(Enum): created = 'created' updated = 'updated' unchanged = 'unchanged' failed = 'failed' deleted = 'deleted'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var createdvar deletedvar failedvar unchangedvar updated
class Action (*args, **kwds)-
Expand source code
class CreativeAction(Enum): created = 'created' updated = 'updated' unchanged = 'unchanged' failed = 'failed' deleted = 'deleted'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var createdvar deletedvar failedvar unchangedvar updated
class CreativeAgent (**data: Any)-
Expand source code
class CreativeAgent(AdCPBaseModel): agent_name: Annotated[ str | None, Field(description='Human-readable name for the creative agent') ] = None agent_url: Annotated[ AnyUrl, Field( description="Base URL for the creative agent (e.g., 'https://reference.adcp.org', 'https://dco.example.com'). Call list_creative_formats on this URL to get its formats." ), ] capabilities: Annotated[ list[creative_agent_capability.CreativeAgentCapability] | None, Field(description='Capabilities this creative agent provides'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var agent_name : str | Nonevar agent_url : pydantic.networks.AnyUrlvar capabilities : list[CreativeAgentCapability] | Nonevar model_config
Inherited members
class CreativeAgentCapability (*args, **kwds)-
Expand source code
class CreativeAgentCapability(Enum): validation = 'validation' assembly = 'assembly' generation = 'generation' preview = 'preview' delivery = 'delivery'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var assemblyvar deliveryvar generationvar previewvar validation
class Capability (*args, **kwds)-
Expand source code
class CreativeAgentCapability(Enum): validation = 'validation' assembly = 'assembly' generation = 'generation' preview = 'preview' delivery = 'delivery'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var assemblyvar deliveryvar generationvar previewvar validation
class CreativeApproval (**data: Any)-
Expand source code
class CreativeApproval(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) approval_status: creative_approval_status.CreativeApprovalStatus creative_id: Annotated[str, Field(description='Creative identifier')] rejection_reason: Annotated[ str | None, Field( description="Human-readable explanation of why the creative was rejected. Present only when approval_status is 'rejected'." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var approval_status : CreativeApprovalStatusvar creative_id : strvar model_configvar rejection_reason : str | None
Inherited members
class CreativeApprovalStatus (*args, **kwds)-
Expand source code
class CreativeApprovalStatus(Enum): pending_review = 'pending_review' approved = 'approved' rejected = 'rejected'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var approvedvar pending_reviewvar rejected
class CreativeAsset (**data: Any)-
Expand source code
class CreativeAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assets: Annotated[ dict[ Annotated[str, StringConstraints(pattern=r'^[a-z0-9_]+$')], image_asset.ImageAsset | video_asset.VideoAsset | audio_asset.AudioAsset | vast_asset.VastAsset | text_asset.TextAsset | url_asset.UrlAsset | html_asset.HtmlAsset | javascript_asset.JavascriptAsset | webhook_asset.WebhookAsset | css_asset.CssAsset | daast_asset.DaastAsset | markdown_asset.MarkdownAsset | brief_asset.BriefAsset | catalog_asset.CatalogAsset, ], Field(description='Assets required by the format, keyed by asset_id'), ] creative_id: Annotated[str, Field(description='Unique identifier for the creative')] format_id: Annotated[ format_id_1.FormatId, Field( description='Format identifier specifying which format this creative conforms to. Can be: (1) concrete format_id referencing a format with fixed dimensions, (2) template format_id referencing a template format, or (3) parameterized format_id with dimensions/duration parameters for template formats.' ), ] inputs: Annotated[ list[Input] | None, Field( description='Preview contexts for generative formats - defines what scenarios to generate previews for' ), ] = None name: Annotated[str, Field(description='Human-readable creative name')] placement_ids: Annotated[ list[str] | None, Field( description="Optional array of placement IDs where this creative should run when uploading via create_media_buy or update_media_buy. References placement_id values from the product's placements array. If omitted, creative runs on all placements. Only used during upload to media buy - not stored in creative library.", min_length=1, ), ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this creative. Serves as the default provenance for all manifests and assets within this creative. A manifest or asset with its own provenance replaces this object entirely (no field-level merging).' ), ] = None status: Annotated[ creative_status.CreativeStatus | None, Field( description="For generative creatives: set to 'approved' to finalize, 'rejected' to request regeneration with updated assets/message. Omit for non-generative creatives (system will set based on processing state)." ), ] = None tags: Annotated[ list[str] | None, Field(description='User-defined tags for organization and searchability') ] = None weight: Annotated[ float | None, Field( description='Optional delivery weight for creative rotation when uploading via create_media_buy or update_media_buy (0-100). If omitted, platform determines rotation. Only used during upload to media buy - not stored in creative library.', ge=0.0, le=100.0, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assets : dict[str, ImageAsset | VideoAsset | AudioAsset | VastAsset | TextAsset | UrlAsset | HtmlAsset | JavascriptAsset | WebhookAsset | CssAsset | DaastAsset | MarkdownAsset | BriefAsset | CatalogAsset]var creative_id : strvar format_id : FormatIdvar inputs : list[Input] | Nonevar model_configvar name : strvar placement_ids : list[str] | Nonevar provenance : Provenance | Nonevar status : CreativeStatus | Nonevar weight : float | None
Inherited members
class CreativeAssignment (**data: Any)-
Expand source code
class CreativeAssignment(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) creative_id: Annotated[str, Field(description='Unique identifier for the creative')] placement_ids: Annotated[ list[str] | None, Field( description="Optional array of placement IDs where this creative should run. When omitted, the creative runs on all placements in the package. References placement_id values from the product's placements array.", min_length=1, ), ] = None weight: Annotated[ float | None, Field( description='Relative delivery weight for this creative (0–100). When multiple creatives are assigned to the same package, weights determine impression distribution proportionally — a creative with weight 2 gets twice the delivery of weight 1. When omitted, the creative receives equal rotation with other unweighted creatives. A weight of 0 means the creative is assigned but paused (receives no delivery).', ge=0.0, le=100.0, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var creative_id : strvar model_configvar placement_ids : list[str] | Nonevar weight : float | None
Inherited members
class CreativeFilters (**data: Any)-
Expand source code
class CreativeFilters(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accounts: Annotated[ list[account_ref.AccountReference] | None, Field( description='Filter creatives by owning accounts. Useful for agencies managing multiple client accounts.', min_length=1, ), ] = None assigned_to_packages: Annotated[ list[str] | None, Field( description='Filter creatives assigned to any of these packages. Sales-agent-specific — standalone creative agents SHOULD ignore this filter.', min_length=1, ), ] = None concept_ids: Annotated[ list[str] | None, Field( description='Filter by creative concept IDs. Concepts group related creatives across sizes and formats (e.g., Flashtalking concepts, Celtra campaign folders, CM360 creative groups).', min_length=1, ), ] = None created_after: Annotated[ AwareDatetime | None, Field(description='Filter creatives created after this date (ISO 8601)'), ] = None created_before: Annotated[ AwareDatetime | None, Field(description='Filter creatives created before this date (ISO 8601)'), ] = None creative_ids: Annotated[ list[str] | None, Field(description='Filter by specific creative IDs', max_length=100, min_length=1), ] = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Filter by structured format IDs. Returns creatives that match any of these formats.', min_length=1, ), ] = None has_served: Annotated[ bool | None, Field( description='When true, return only creatives that have served at least one impression. When false, return only creatives that have never served.' ), ] = None has_variables: Annotated[ bool | None, Field( description='When true, return only creatives with dynamic variables (DCO). When false, return only static creatives.' ), ] = None media_buy_ids: Annotated[ list[str] | None, Field( description='Filter creatives assigned to any of these media buys. Sales-agent-specific — standalone creative agents SHOULD ignore this filter.', min_length=1, ), ] = None name_contains: Annotated[ str | None, Field(description='Filter by creative names containing this text (case-insensitive)'), ] = None statuses: Annotated[ list[creative_status.CreativeStatus] | None, Field(description='Filter by creative approval statuses', min_length=1), ] = None tags: Annotated[ list[str] | None, Field(description='Filter by creative tags (all tags must match)', min_length=1), ] = None tags_any: Annotated[ list[str] | None, Field(description='Filter by creative tags (any tag must match)', min_length=1), ] = None unassigned: Annotated[ bool | None, Field( description='Filter for unassigned creatives when true, assigned creatives when false. Sales-agent-specific — standalone creative agents SHOULD ignore this filter.' ), ] = None updated_after: Annotated[ AwareDatetime | None, Field(description='Filter creatives last updated after this date (ISO 8601)'), ] = None updated_before: Annotated[ AwareDatetime | None, Field(description='Filter creatives last updated before this date (ISO 8601)'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accounts : list[AccountReference] | Nonevar assigned_to_packages : list[str] | Nonevar concept_ids : list[str] | Nonevar created_after : pydantic.types.AwareDatetime | Nonevar created_before : pydantic.types.AwareDatetime | Nonevar creative_ids : list[str] | Nonevar format_ids : list[FormatId] | Nonevar has_served : bool | Nonevar has_variables : bool | Nonevar media_buy_ids : list[str] | Nonevar model_configvar name_contains : str | Nonevar statuses : list[CreativeStatus] | Nonevar unassigned : bool | Nonevar updated_after : pydantic.types.AwareDatetime | Nonevar updated_before : pydantic.types.AwareDatetime | None
Inherited members
class CreativeManifest (**data: Any)-
Expand source code
class CreativeManifest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assets: Annotated[ dict[ Annotated[str, StringConstraints(pattern=r'^[a-z0-9_]+$')], image_asset.ImageAsset | video_asset.VideoAsset | audio_asset.AudioAsset | vast_asset.VastAsset | text_asset.TextAsset | url_asset.UrlAsset | html_asset.HtmlAsset | javascript_asset.JavascriptAsset | webhook_asset.WebhookAsset | css_asset.CssAsset | daast_asset.DaastAsset | markdown_asset.MarkdownAsset | brief_asset.BriefAsset | catalog_asset.CatalogAsset, ], Field( description="Map of asset IDs to actual asset content. Each key MUST match an asset_id from the format's assets array (e.g., 'banner_image', 'clickthrough_url', 'video_file', 'vast_tag'). The asset_id is the technical identifier used to match assets to format requirements.\n\nIMPORTANT: Full validation requires format context. The format defines what type each asset_id should be. Standalone schema validation only checks structural conformance — each asset must match at least one valid asset type schema." ), ] ext: ext_1.ExtensionObject | None = None format_id: Annotated[ format_id_1.FormatId, Field( description="Format identifier this manifest is for. Can be a template format (id only) or a deterministic format (id + dimensions/duration). For dimension-specific creatives, include width/height/unit in the format_id to create a unique identifier (e.g., {id: 'display_static', width: 300, height: 250, unit: 'px'})." ), ] provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this creative manifest. Serves as the default provenance for all assets in this manifest. An asset with its own provenance replaces this object entirely (no field-level merging).' ), ] = None rights: Annotated[ list[rights_constraint.RightsConstraint] | None, Field( description='Rights constraints attached to this creative. Each entry represents constraints from a single rights holder. A creative may combine multiple rights constraints (e.g., talent likeness + music license). For v1, rights constraints are informational metadata — the buyer/orchestrator manages creative lifecycle against these terms.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assets : dict[str, ImageAsset | VideoAsset | AudioAsset | VastAsset | TextAsset | UrlAsset | HtmlAsset | JavascriptAsset | WebhookAsset | CssAsset | DaastAsset | MarkdownAsset | BriefAsset | CatalogAsset]var ext : ExtensionObject | Nonevar format_id : FormatIdvar model_configvar provenance : Provenance | Nonevar rights : list[RightsConstraint] | None
Inherited members
class CreativePolicy (**data: Any)-
Expand source code
class CreativePolicy(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) co_branding: Annotated[ co_branding_requirement.CoBrandingRequirement, Field(description='Co-branding requirement') ] landing_page: Annotated[ landing_page_requirement.LandingPageRequirement, Field(description='Landing page requirements'), ] provenance_required: Annotated[ bool | None, Field( description='Whether creatives must include provenance metadata. When true, the seller requires buyers to attach provenance declarations to creative submissions. The seller may independently verify claims via get_creative_features.' ), ] = None templates_available: Annotated[ bool, Field(description='Whether creative templates are provided') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var co_branding : CoBrandingRequirementvar landing_page : LandingPageRequirementvar model_configvar provenance_required : bool | Nonevar templates_available : bool
Inherited members
class CreativeStatus (*args, **kwds)-
Expand source code
class CreativeStatus(Enum): processing = 'processing' pending_review = 'pending_review' approved = 'approved' rejected = 'rejected' archived = 'archived'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var approvedvar archivedvar pending_reviewvar processingvar rejected
class CreativeVariant (**data: Any)-
Expand source code
class CreativeVariant(DeliveryMetrics): generation_context: Annotated[ GenerationContext | None, Field( description='Input signals that triggered generation of this variant (Tier 3). Describes why the platform created this specific variant. Platforms should provide summarized or anonymized signals rather than raw user input. For web contexts, may include page topic or URL. For conversational contexts, an anonymized content signal. For search, query category or intent. When the content context is managed through AdCP content standards, reference the artifact directly via the artifact field.' ), ] = None manifest: Annotated[ creative_manifest.CreativeManifest | None, Field( description='The rendered creative manifest for this variant — the actual output that was served, not the input assets. Contains format_id and the resolved assets (specific headline, image, video, etc. the platform selected or generated). For Tier 2, shows which asset combination was picked. For Tier 3, contains the generated assets which may differ entirely from the input brand identity. Pass to preview_creative to re-render.' ), ] = None variant_id: Annotated[str, Field(description='Platform-assigned identifier for this variant')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- DeliveryMetrics
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var generation_context : GenerationContext | Nonevar manifest : CreativeManifest | Nonevar model_configvar variant_id : str
Inherited members
class CssAsset (**data: Any)-
Expand source code
class CssAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) content: Annotated[str, Field(description='CSS content')] media: Annotated[ str | None, Field(description="CSS media query context (e.g., 'screen', 'print')") ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var content : strvar media : str | Nonevar model_configvar provenance : Provenance | None
Inherited members
class UrlDaastAsset (**data: Any)-
Expand source code
class DaastAsset1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) companion_ads: Annotated[ bool | None, Field(description='Whether companion display ads are included') ] = None daast_version: Annotated[ daast_version_1.DaastVersion | None, Field(description='DAAST specification version') ] = None delivery_type: Annotated[ Literal['url'], Field(description='Discriminator indicating DAAST is delivered via URL endpoint'), ] duration_ms: Annotated[ int | None, Field(description='Expected audio duration in milliseconds (if known)', ge=0) ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None tracking_events: Annotated[ list[daast_tracking_event.DaastTrackingEvent] | None, Field(description='Tracking events supported by this DAAST tag'), ] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = None url: Annotated[AnyUrl, Field(description='URL endpoint that returns DAAST XML')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var companion_ads : bool | Nonevar daast_version : DaastVersion | Nonevar delivery_type : Literal['url']var duration_ms : int | Nonevar model_configvar provenance : Provenance | Nonevar tracking_events : list[DaastTrackingEvent] | Nonevar transcript_url : pydantic.networks.AnyUrl | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class InlineDaastAsset (**data: Any)-
Expand source code
class DaastAsset2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) companion_ads: Annotated[ bool | None, Field(description='Whether companion display ads are included') ] = None content: Annotated[str, Field(description='Inline DAAST XML content')] daast_version: Annotated[ daast_version_1.DaastVersion | None, Field(description='DAAST specification version') ] = None delivery_type: Annotated[ Literal['inline'], Field(description='Discriminator indicating DAAST is delivered as inline XML content'), ] duration_ms: Annotated[ int | None, Field(description='Expected audio duration in milliseconds (if known)', ge=0) ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None tracking_events: Annotated[ list[daast_tracking_event.DaastTrackingEvent] | None, Field(description='Tracking events supported by this DAAST tag'), ] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var companion_ads : bool | Nonevar content : strvar daast_version : DaastVersion | Nonevar delivery_type : Literal['inline']var duration_ms : int | Nonevar model_configvar provenance : Provenance | Nonevar tracking_events : list[DaastTrackingEvent] | Nonevar transcript_url : pydantic.networks.AnyUrl | None
Inherited members
class DaastTrackingEvent (*args, **kwds)-
Expand source code
class DaastTrackingEvent(Enum): start = 'start' firstQuartile = 'firstQuartile' midpoint = 'midpoint' thirdQuartile = 'thirdQuartile' complete = 'complete' impression = 'impression' pause = 'pause' resume = 'resume' skip = 'skip' mute = 'mute' unmute = 'unmute'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var completevar firstQuartilevar impressionvar midpointvar mutevar pausevar resumevar skipvar startvar thirdQuartilevar unmute
class DaastVersion (*args, **kwds)-
Expand source code
class DaastVersion(Enum): field_1_0 = '1.0' field_1_1 = '1.1'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var field_1_0var field_1_1
class DailyBreakdownItem (**data: Any)-
Expand source code
class DailyBreakdownItem(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) conversion_value: Annotated[ float | None, Field(description='Daily conversion value for this package', ge=0.0) ] = None conversions: Annotated[ float | None, Field(description='Daily conversions for this package', ge=0.0) ] = None date: Annotated[str, Field(description='Date (YYYY-MM-DD)', pattern='^\\d{4}-\\d{2}-\\d{2}$')] impressions: Annotated[float, Field(description='Daily impressions for this package', ge=0.0)] new_to_brand_rate: Annotated[ float | None, Field( description='Daily fraction of conversions from first-time brand buyers (0 = none, 1 = all)', ge=0.0, le=1.0, ), ] = None roas: Annotated[ float | None, Field(description='Daily return on ad spend (conversion_value / spend)', ge=0.0), ] = None spend: Annotated[float, Field(description='Daily spend for this package', ge=0.0)]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var conversion_value : float | Nonevar conversions : float | Nonevar date : strvar impressions : floatvar model_configvar new_to_brand_rate : float | Nonevar roas : float | Nonevar spend : float
Inherited members
class DateRange (**data: Any)-
Expand source code
class DateRange(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) end: Annotated[date_aliased, Field(description='End date (inclusive), ISO 8601')] start: Annotated[date_aliased, Field(description='Start date (inclusive), ISO 8601')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var end : datetime.datevar model_configvar start : datetime.date
Inherited members
class DatetimeRange (**data: Any)-
Expand source code
class DatetimeRange(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) end: Annotated[AwareDatetime, Field(description='End timestamp (inclusive), ISO 8601')] start: Annotated[AwareDatetime, Field(description='Start timestamp (inclusive), ISO 8601')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var end : pydantic.types.AwareDatetimevar model_configvar start : pydantic.types.AwareDatetime
Inherited members
class DayOfWeek (*args, **kwds)-
Expand source code
class DayOfWeek(Enum): monday = 'monday' tuesday = 'tuesday' wednesday = 'wednesday' thursday = 'thursday' friday = 'friday' saturday = 'saturday' sunday = 'sunday'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var fridayvar mondayvar saturdayvar sundayvar thursdayvar tuesdayvar wednesday
class DaypartTarget (**data: Any)-
Expand source code
class DaypartTarget(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) days: Annotated[ list[day_of_week.DayOfWeek], Field( description='Days of week this window applies to. Use multiple days for compact targeting (e.g., monday-friday in one object).', min_length=1, ), ] end_hour: Annotated[ int, Field( description='End hour (exclusive), 1-24 in 24-hour format. 10 = 10:00am, 24 = midnight. Must be greater than start_hour.', ge=1, le=24, ), ] label: Annotated[ str | None, Field( description="Optional human-readable name for this time window (e.g., 'Morning Drive', 'Prime Time')" ), ] = None start_hour: Annotated[ int, Field( description='Start hour (inclusive), 0-23 in 24-hour format. 0 = midnight, 6 = 6:00am, 18 = 6:00pm.', ge=0, le=23, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var days : list[DayOfWeek]var end_hour : intvar label : str | Nonevar model_configvar start_hour : int
Inherited members
class DeletePropertyListRequest (**data: Any)-
Expand source code
class DeletePropertyListRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. 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, ), ] = None list_id: Annotated[str, Field(description='ID of the property list to delete')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar list_id : strvar model_config
Inherited members
class DeletePropertyListResponse (**data: Any)-
Expand source code
class DeletePropertyListResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) deleted: Annotated[bool, Field(description='Whether the list was successfully deleted')] ext: ext_1.ExtensionObject | None = None list_id: Annotated[str, Field(description='ID of the deleted list')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var deleted : boolvar ext : ExtensionObject | Nonevar list_id : strvar model_config
Inherited members
class DeliveryForecast (**data: Any)-
Expand source code
class DeliveryForecast(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code for monetary values in this forecast (spend, budget)' ), ] demographic: Annotated[ str | None, Field( description='Target demographic code within the specified demographic_system. For Nielsen: P18-49, M25-54, W35+. For BARB: ABC1 Adults, 16-34. For AGF: E 14-49.', examples=['P18-49', 'A25-54', 'W35+', 'M18-34'], ), ] = None demographic_system: Annotated[ demographic_system_1.DemographicSystem | None, Field( description='Measurement system for the demographic field. Ensures buyer and seller agree on demographic notation.' ), ] = None ext: ext_1.ExtensionObject | None = None forecast_range_unit: Annotated[ forecast_range_unit_1.ForecastRangeUnit | None, Field( description="How to interpret the points array. 'spend' (default when omitted): points at ascending budget levels. 'availability': total available inventory, budget omitted. 'reach_freq': points at ascending reach/frequency targets. 'weekly'/'daily': metrics are per-period values. 'clicks'/'conversions': points at ascending outcome targets." ), ] = None generated_at: Annotated[ AwareDatetime | None, Field(description='When this forecast was computed') ] = None method: Annotated[ forecast_method.ForecastMethod, Field(description='Method used to produce this forecast') ] points: Annotated[ list[forecast_point.ForecastPoint], Field( description='Forecasted delivery data points. For spend curves (default), points at ascending budget levels show how metrics scale with spend. For availability forecasts, points represent total available inventory independent of budget. See forecast_range_unit for interpretation.', min_length=1, ), ] reach_unit: Annotated[ reach_unit_1.ReachUnit | None, Field( description='Unit of measurement for reach and audience_size metrics in this forecast. Required for cross-channel forecast comparison.' ), ] = None valid_until: Annotated[ AwareDatetime | None, Field( description='When this forecast expires. After this time, the forecast should be refreshed. Forecast expiry does not affect proposal executability.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar demographic : str | Nonevar demographic_system : DemographicSystem | Nonevar ext : ExtensionObject | Nonevar forecast_range_unit : ForecastRangeUnit | Nonevar generated_at : pydantic.types.AwareDatetime | Nonevar method : ForecastMethodvar model_configvar points : list[ForecastPoint]var reach_unit : ReachUnit | Nonevar valid_until : pydantic.types.AwareDatetime | None
Inherited members
class DeliveryMeasurement (**data: Any)-
Expand source code
class DeliveryMeasurement(AdCPBaseModel): notes: Annotated[ str | None, Field( description="Additional details about measurement methodology in plain language (e.g., 'MRC-accredited viewability. 50% in-view for 1s display / 2s video', 'Panel-based demographic measurement updated monthly')" ), ] = None provider: Annotated[ str, Field( description="Measurement provider(s) used for this product (e.g., 'Google Ad Manager with IAS viewability', 'Nielsen DAR', 'Geopath for DOOH impressions')" ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar notes : str | Nonevar provider : str
Inherited members
class DeliveryMetrics (**data: Any)-
Expand source code
class DeliveryMetrics(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) by_action_source: Annotated[ list[ByActionSourceItem] | None, Field( description='Conversion metrics broken down by action source (website, app, in_store, etc.). Useful for omnichannel sellers where conversions occur across digital and physical channels.' ), ] = None by_event_type: Annotated[ list[ByEventTypeItem] | None, Field( description='Conversion metrics broken down by event type. Spend-derived metrics (ROAS, CPA) are only available at the package/totals level since spend cannot be attributed to individual event types.' ), ] = None clicks: Annotated[float | None, Field(description='Total clicks', ge=0.0)] = None completed_views: Annotated[ float | None, Field( description='Video/audio completions. When the package has a completed_views optimization goal with view_duration_seconds, completions are counted at that threshold rather than 100% completion.', ge=0.0, ), ] = None completion_rate: Annotated[ float | None, Field(description='Completion rate (completed_views/impressions)', ge=0.0, le=1.0), ] = None conversion_value: Annotated[ float | None, Field( description='Total monetary value of attributed conversions (in the reporting currency)', ge=0.0, ), ] = None conversions: Annotated[ float | None, Field( description='Total conversions attributed to this delivery. When by_event_type is present, this equals the sum of all by_event_type[].count entries.', ge=0.0, ), ] = None cost_per_acquisition: Annotated[ float | None, Field(description='Cost per conversion (spend / conversions)', ge=0.0) ] = None cost_per_click: Annotated[ float | None, Field(description='Cost per click (spend / clicks)', ge=0.0) ] = None ctr: Annotated[ float | None, Field(description='Click-through rate (clicks/impressions)', ge=0.0, le=1.0) ] = None dooh_metrics: Annotated[ DoohMetrics | None, Field(description='DOOH-specific metrics (only included for DOOH campaigns)'), ] = None engagement_rate: Annotated[ float | None, Field( description='Platform-specific engagement rate (0.0 to 1.0). Typically engagements/impressions, but definition varies by platform.', ge=0.0, le=1.0, ), ] = None engagements: Annotated[ float | None, Field( description="Total engagements — direct interactions with the ad beyond viewing. Includes social reactions/comments/shares, story/unit opens, interactive overlay taps on CTV, companion banner interactions on audio. Platform-specific; corresponds to the 'engagements' optimization metric.", ge=0.0, ), ] = None follows: Annotated[ float | None, Field( description='New followers, page likes, artist/podcast/channel subscribes attributed to this delivery.', ge=0.0, ), ] = None frequency: Annotated[ float | None, Field( description="Average frequency per reach unit (typically measured over campaign duration, but can vary by measurement provider). When reach_unit is 'households', this is average exposures per household; when 'accounts', per logged-in account; etc.", ge=0.0, ), ] = None grps: Annotated[ float | None, Field(description='Gross Rating Points delivered (for CPP)', ge=0.0) ] = None impressions: Annotated[float | None, Field(description='Impressions delivered', ge=0.0)] = None leads: Annotated[ float | None, Field( description="Leads generated (convenience alias for by_event_type where event_type='lead')", ge=0.0, ), ] = None new_to_brand_rate: Annotated[ float | None, Field( description='Fraction of conversions from first-time brand buyers (0 = none, 1 = all)', ge=0.0, le=1.0, ), ] = None profile_visits: Annotated[ float | None, Field( description="Visits to the brand's in-platform page (profile, artist page, channel, or storefront) attributed to this delivery. Does not include external website clicks.", ge=0.0, ), ] = None quartile_data: Annotated[ QuartileData | None, Field(description='Audio/video quartile completion data') ] = None reach: Annotated[ float | None, Field( description='Unique reach in the units specified by reach_unit. When reach_unit is omitted, units are unspecified — do not compare reach values across packages or media buys without a common reach_unit.', ge=0.0, ), ] = None reach_unit: Annotated[ reach_unit_1.ReachUnit | None, Field( description='Unit of measurement for the reach field. Aligns with the reach_unit declared on optimization goals and delivery forecasts. Required when reach is present to enable cross-platform comparison.' ), ] = None roas: Annotated[ float | None, Field(description='Return on ad spend (conversion_value / spend)', ge=0.0) ] = None saves: Annotated[ float | None, Field( description='Saves, bookmarks, playlist adds, pins attributed to this delivery.', ge=0.0 ), ] = None spend: Annotated[float | None, Field(description='Amount spent', ge=0.0)] = None viewability: Annotated[ Viewability | None, Field( description='Viewability metrics. Viewable rate should be calculated as viewable_impressions / measurable_impressions (not total impressions), since some environments cannot measure viewability.' ), ] = None views: Annotated[ float | None, Field( description="Content engagements counted toward the billable view threshold. For video this is a platform-defined view event (e.g., 30 seconds or video midpoint); for audio/podcast it is a stream start; for other formats it follows the pricing model's view definition. When the package uses CPV pricing, spend = views × rate.", ge=0.0, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Subclasses
- CreativeVariant
- ByAudienceItem
- ByCatalogItemItem
- ByCreativeItem
- ByDevicePlatformItem
- ByDeviceTypeItem
- ByGeoItem
- ByKeywordItem
- ByPackageItem
- ByPlacementItem
- Totals
Class variables
var by_action_source : list[ByActionSourceItem] | Nonevar by_event_type : list[ByEventTypeItem] | Nonevar clicks : float | Nonevar completed_views : float | Nonevar completion_rate : float | Nonevar conversion_value : float | Nonevar conversions : float | Nonevar cost_per_acquisition : float | Nonevar cost_per_click : float | Nonevar ctr : float | Nonevar dooh_metrics : DoohMetrics | Nonevar engagement_rate : float | Nonevar engagements : float | Nonevar follows : float | Nonevar frequency : float | Nonevar grps : float | Nonevar impressions : float | Nonevar leads : float | Nonevar model_configvar new_to_brand_rate : float | Nonevar profile_visits : float | Nonevar quartile_data : QuartileData | Nonevar reach : float | Nonevar reach_unit : ReachUnit | Nonevar roas : float | Nonevar saves : float | Nonevar spend : float | Nonevar viewability : Viewability | Nonevar views : float | None
Inherited members
class DeliveryStatus (*args, **kwds)-
Expand source code
class DeliveryStatus(Enum): delivering = 'delivering' not_delivering = 'not_delivering' completed = 'completed' budget_exhausted = 'budget_exhausted' flight_ended = 'flight_ended' goal_met = 'goal_met'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var budget_exhaustedvar completedvar deliveringvar flight_endedvar goal_metvar not_delivering
class DeliveryType (*args, **kwds)-
Expand source code
class DeliveryType(Enum): guaranteed = 'guaranteed' non_guaranteed = 'non_guaranteed'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var guaranteedvar non_guaranteed
class DemographicSystem (*args, **kwds)-
Expand source code
class DemographicSystem(Enum): nielsen = 'nielsen' barb = 'barb' agf = 'agf' oztam = 'oztam' mediametrie = 'mediametrie' custom = 'custom'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var agfvar barbvar customvar mediametrievar nielsenvar oztam
class PlatformDeployment (**data: Any)-
Expand source code
class Deployment1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[str | None, Field(description='Account identifier if applicable')] = None activation_key: Annotated[ activation_key_1.ActivationKey | None, Field( description='The key to use for targeting. Only present if is_live=true AND requester has access to this deployment.' ), ] = None deployed_at: Annotated[ AwareDatetime | None, Field(description='Timestamp when activation completed (if is_live=true)'), ] = None estimated_activation_duration_minutes: Annotated[ float | None, Field( description='Estimated time to activate if not live, or to complete activation if in progress', ge=0.0, ), ] = None is_live: Annotated[ bool, Field(description='Whether signal is currently active on this deployment') ] platform: Annotated[str, Field(description='Platform identifier for DSPs')] type: Annotated[ Literal['platform'], Field(description='Discriminator indicating this is a platform-based deployment'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : str | Nonevar activation_key : ActivationKey | Nonevar deployed_at : pydantic.types.AwareDatetime | Nonevar estimated_activation_duration_minutes : float | Nonevar is_live : boolvar model_configvar platform : strvar type : Literal['platform']
Inherited members
class AgentDeployment (**data: Any)-
Expand source code
class Deployment2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[str | None, Field(description='Account identifier if applicable')] = None activation_key: Annotated[ activation_key_1.ActivationKey | None, Field( description='The key to use for targeting. Only present if is_live=true AND requester has access to this deployment.' ), ] = None agent_url: Annotated[AnyUrl, Field(description='URL identifying the deployment agent')] deployed_at: Annotated[ AwareDatetime | None, Field(description='Timestamp when activation completed (if is_live=true)'), ] = None estimated_activation_duration_minutes: Annotated[ float | None, Field( description='Estimated time to activate if not live, or to complete activation if in progress', ge=0.0, ), ] = None is_live: Annotated[ bool, Field(description='Whether signal is currently active on this deployment') ] type: Annotated[ Literal['agent'], Field(description='Discriminator indicating this is an agent URL-based deployment'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : str | Nonevar activation_key : ActivationKey | Nonevar agent_url : pydantic.networks.AnyUrlvar deployed_at : pydantic.types.AwareDatetime | Nonevar estimated_activation_duration_minutes : float | Nonevar is_live : boolvar model_configvar type : Literal['agent']
Inherited members
class PlatformDestination (**data: Any)-
Expand source code
class Destination1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ str | None, Field(description='Optional account identifier on the platform') ] = None platform: Annotated[ str, Field(description="Platform identifier for DSPs (e.g., 'the-trade-desk', 'amazon-dsp')"), ] type: Annotated[ Literal['platform'], Field(description='Discriminator indicating this is a platform-based deployment'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : str | Nonevar model_configvar platform : strvar type : Literal['platform']
Inherited members
class AgentDestination (**data: Any)-
Expand source code
class Destination2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ str | None, Field(description='Optional account identifier on the agent') ] = None agent_url: Annotated[ AnyUrl, Field(description='URL identifying the deployment agent (for sales agents, etc.)') ] type: Annotated[ Literal['agent'], Field(description='Discriminator indicating this is an agent URL-based deployment'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : str | Nonevar agent_url : pydantic.networks.AnyUrlvar model_configvar type : Literal['agent']
Inherited members
class DevicePlatform (*args, **kwds)-
Expand source code
class DevicePlatform(Enum): ios = 'ios' android = 'android' windows = 'windows' macos = 'macos' linux = 'linux' chromeos = 'chromeos' tvos = 'tvos' tizen = 'tizen' webos = 'webos' fire_os = 'fire_os' roku_os = 'roku_os' unknown = 'unknown'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var androidvar chromeosvar fire_osvar iosvar linuxvar macosvar roku_osvar tizenvar tvosvar unknownvar webosvar windows
class DeviceType (*args, **kwds)-
Expand source code
class DeviceType(Enum): desktop = 'desktop' mobile = 'mobile' tablet = 'tablet' ctv = 'ctv' dooh = 'dooh' unknown = 'unknown'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var ctvvar desktopvar doohvar mobilevar tabletvar unknown
class DimensionUnit (*args, **kwds)-
Expand source code
class DimensionUnit(Enum): px = 'px' dp = 'dp' inches = 'inches' cm = 'cm' mm = 'mm' pt = 'pt'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var cmvar dpvar inchesvar mmvar ptvar px
class Unit (*args, **kwds)-
Expand source code
class DimensionUnit(Enum): px = 'px' dp = 'dp' inches = 'inches' cm = 'cm' mm = 'mm' pt = 'pt'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var cmvar dpvar inchesvar mmvar ptvar px
class Disclaimer (**data: Any)-
Expand source code
class Disclaimer(AdCPBaseModel): context: str | None = None required: bool | None = True text: strBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : str | Nonevar model_configvar required : bool | Nonevar text : str
Inherited members
class DoohMetrics (**data: Any)-
Expand source code
class DoohMetrics(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) calculation_notes: Annotated[ str | None, Field(description='Explanation of how DOOH impressions were calculated') ] = None loop_plays: Annotated[ int | None, Field(description='Number of times ad played in rotation', ge=0) ] = None screen_time_seconds: Annotated[ int | None, Field(description='Total display time in seconds', ge=0) ] = None screens_used: Annotated[ int | None, Field(description='Number of unique screens displaying the ad', ge=0) ] = None sov_achieved: Annotated[ float | None, Field(description='Actual share of voice delivered (0.0 to 1.0)', ge=0.0, le=1.0), ] = None venue_breakdown: Annotated[ list[VenueBreakdownItem] | None, Field(description='Per-venue performance breakdown') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var calculation_notes : str | Nonevar loop_plays : int | Nonevar model_configvar screen_time_seconds : int | Nonevar screens_used : int | Nonevar sov_achieved : float | Nonevar venue_breakdown : list[VenueBreakdownItem] | None
Inherited members
class Duration (**data: Any)-
Expand source code
class Duration(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) interval: Annotated[ int, Field(description="Number of time units. Must be 1 when unit is 'campaign'.", ge=1) ] unit: Annotated[ Unit, Field( description="Time unit. 'seconds' for sub-minute precision. 'campaign' spans the full campaign flight." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var interval : intvar model_configvar unit : Unit
Inherited members
class Error (**data: Any)-
Expand source code
class Error(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) code: Annotated[ str, Field( description='Error code for programmatic handling. Standard codes are defined in error-code.json and enable autonomous agent recovery. Sellers MAY use codes not in the standard vocabulary for platform-specific errors; agents MUST handle unknown codes gracefully by falling back to the recovery classification.', max_length=64, min_length=1, ), ] details: Annotated[ dict[str, Any] | None, Field(description='Additional task-specific error details') ] = None field: Annotated[ str | None, Field(description="Field path associated with the error (e.g., 'packages[0].targeting')"), ] = None message: Annotated[str, Field(description='Human-readable error message')] recovery: Annotated[ Recovery | None, Field( description='Agent recovery classification. transient: retry after delay (rate limit, service unavailable, timeout). correctable: fix the request and resend (invalid field, budget too low, creative rejected). terminal: requires human action (account suspended, payment required, account not found).' ), ] = None retry_after: Annotated[ float | None, Field( description='Seconds to wait before retrying the operation. Sellers MUST return values between 1 and 3600. Clients MUST clamp values outside this range.', ge=1.0, le=3600.0, ), ] = None suggestion: Annotated[str | None, Field(description='Suggested fix for the error')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var code : strvar details : dict[str, typing.Any] | Nonevar field : str | Nonevar message : strvar model_configvar recovery : Recovery | Nonevar retry_after : float | Nonevar suggestion : str | None
Inherited members
class ErrorCode (*args, **kwds)-
Expand source code
class ErrorCode(Enum): INVALID_REQUEST = 'INVALID_REQUEST' AUTH_REQUIRED = 'AUTH_REQUIRED' RATE_LIMITED = 'RATE_LIMITED' SERVICE_UNAVAILABLE = 'SERVICE_UNAVAILABLE' POLICY_VIOLATION = 'POLICY_VIOLATION' PRODUCT_NOT_FOUND = 'PRODUCT_NOT_FOUND' PRODUCT_UNAVAILABLE = 'PRODUCT_UNAVAILABLE' PROPOSAL_EXPIRED = 'PROPOSAL_EXPIRED' BUDGET_TOO_LOW = 'BUDGET_TOO_LOW' CREATIVE_REJECTED = 'CREATIVE_REJECTED' UNSUPPORTED_FEATURE = 'UNSUPPORTED_FEATURE' AUDIENCE_TOO_SMALL = 'AUDIENCE_TOO_SMALL' ACCOUNT_NOT_FOUND = 'ACCOUNT_NOT_FOUND' ACCOUNT_SETUP_REQUIRED = 'ACCOUNT_SETUP_REQUIRED' ACCOUNT_AMBIGUOUS = 'ACCOUNT_AMBIGUOUS' ACCOUNT_PAYMENT_REQUIRED = 'ACCOUNT_PAYMENT_REQUIRED' ACCOUNT_SUSPENDED = 'ACCOUNT_SUSPENDED' COMPLIANCE_UNSATISFIED = 'COMPLIANCE_UNSATISFIED' BUDGET_EXHAUSTED = 'BUDGET_EXHAUSTED' BUDGET_EXCEEDED = 'BUDGET_EXCEEDED' CONFLICT = 'CONFLICT' CREATIVE_DEADLINE_EXCEEDED = 'CREATIVE_DEADLINE_EXCEEDED' INVALID_STATE = 'INVALID_STATE' MEDIA_BUY_NOT_FOUND = 'MEDIA_BUY_NOT_FOUND' NOT_CANCELLABLE = 'NOT_CANCELLABLE' PACKAGE_NOT_FOUND = 'PACKAGE_NOT_FOUND' SESSION_NOT_FOUND = 'SESSION_NOT_FOUND' SESSION_TERMINATED = 'SESSION_TERMINATED' VALIDATION_ERROR = 'VALIDATION_ERROR' PRODUCT_EXPIRED = 'PRODUCT_EXPIRED' PROPOSAL_NOT_COMMITTED = 'PROPOSAL_NOT_COMMITTED' IO_REQUIRED = 'IO_REQUIRED'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var ACCOUNT_AMBIGUOUSvar ACCOUNT_NOT_FOUNDvar ACCOUNT_PAYMENT_REQUIREDvar ACCOUNT_SETUP_REQUIREDvar ACCOUNT_SUSPENDEDvar AUDIENCE_TOO_SMALLvar AUTH_REQUIREDvar BUDGET_EXCEEDEDvar BUDGET_EXHAUSTEDvar BUDGET_TOO_LOWvar COMPLIANCE_UNSATISFIEDvar CONFLICTvar CREATIVE_DEADLINE_EXCEEDEDvar CREATIVE_REJECTEDvar INVALID_REQUESTvar INVALID_STATEvar IO_REQUIREDvar MEDIA_BUY_NOT_FOUNDvar NOT_CANCELLABLEvar PACKAGE_NOT_FOUNDvar POLICY_VIOLATIONvar PRODUCT_EXPIREDvar PRODUCT_NOT_FOUNDvar PRODUCT_UNAVAILABLEvar PROPOSAL_EXPIREDvar PROPOSAL_NOT_COMMITTEDvar RATE_LIMITEDvar SERVICE_UNAVAILABLEvar SESSION_NOT_FOUNDvar SESSION_TERMINATEDvar UNSUPPORTED_FEATUREvar VALIDATION_ERROR
class EventType (*args, **kwds)-
Expand source code
class EventType(Enum): page_view = 'page_view' view_content = 'view_content' select_content = 'select_content' select_item = 'select_item' search = 'search' share = 'share' add_to_cart = 'add_to_cart' remove_from_cart = 'remove_from_cart' viewed_cart = 'viewed_cart' add_to_wishlist = 'add_to_wishlist' initiate_checkout = 'initiate_checkout' add_payment_info = 'add_payment_info' purchase = 'purchase' refund = 'refund' lead = 'lead' qualify_lead = 'qualify_lead' close_convert_lead = 'close_convert_lead' disqualify_lead = 'disqualify_lead' complete_registration = 'complete_registration' subscribe = 'subscribe' start_trial = 'start_trial' app_install = 'app_install' app_launch = 'app_launch' contact = 'contact' schedule = 'schedule' donate = 'donate' submit_application = 'submit_application' custom = 'custom'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var add_payment_infovar add_to_cartvar add_to_wishlistvar app_installvar app_launchvar close_convert_leadvar complete_registrationvar contactvar customvar disqualify_leadvar donatevar initiate_checkoutvar leadvar page_viewvar purchasevar qualify_leadvar refundvar remove_from_cartvar schedulevar searchvar select_contentvar select_itemvar start_trialvar submit_applicationvar subscribevar view_contentvar viewed_cart
class ExtensionObject (**data: Any)-
Expand source code
class ExtensionObject(AdCPBaseModel): model_config = ConfigDict( extra='allow', )Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class FeedFormat (*args, **kwds)-
Expand source code
class FeedFormat(Enum): google_merchant_center = 'google_merchant_center' facebook_catalog = 'facebook_catalog' shopify = 'shopify' linkedin_jobs = 'linkedin_jobs' custom = 'custom'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var customvar facebook_catalogvar google_merchant_centervar linkedin_jobsvar shopify
class FeedbackSource (*args, **kwds)-
Expand source code
class FeedbackSource(Enum): buyer_attribution = 'buyer_attribution' third_party_measurement = 'third_party_measurement' platform_analytics = 'platform_analytics' verification_partner = 'verification_partner'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var buyer_attributionvar platform_analyticsvar third_party_measurementvar verification_partner
class ListCreativesField (*args, **kwds)-
Expand source code
class Field1(Enum): creative_id = 'creative_id' name = 'name' format_id = 'format_id' status = 'status' created_date = 'created_date' updated_date = 'updated_date' tags = 'tags' assignments = 'assignments' snapshot = 'snapshot' items = 'items' variables = 'variables' concept = 'concept'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var assignmentsvar conceptvar created_datevar creative_idvar format_idvar itemsvar namevar snapshotvar statusvar updated_datevar variables
class GetProductsField (*args, **kwds)-
Expand source code
class Field1(Enum): product_id = 'product_id' name = 'name' description = 'description' publisher_properties = 'publisher_properties' channels = 'channels' format_ids = 'format_ids' placements = 'placements' delivery_type = 'delivery_type' exclusivity = 'exclusivity' pricing_options = 'pricing_options' forecast = 'forecast' outcome_measurement = 'outcome_measurement' delivery_measurement = 'delivery_measurement' reporting_capabilities = 'reporting_capabilities' creative_policy = 'creative_policy' catalog_types = 'catalog_types' metric_optimization = 'metric_optimization' conversion_tracking = 'conversion_tracking' data_provider_signals = 'data_provider_signals' max_optimization_goals = 'max_optimization_goals' catalog_match = 'catalog_match' collections = 'collections' collection_targeting_allowed = 'collection_targeting_allowed' installments = 'installments' brief_relevance = 'brief_relevance' expires_at = 'expires_at' product_card = 'product_card' product_card_detailed = 'product_card_detailed' enforced_policies = 'enforced_policies' trusted_match = 'trusted_match'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var brief_relevancevar catalog_matchvar catalog_typesvar channelsvar collection_targeting_allowedvar collectionsvar conversion_trackingvar creative_policyvar data_provider_signalsvar delivery_measurementvar delivery_typevar descriptionvar enforced_policiesvar exclusivityvar expires_atvar forecastvar format_idsvar installmentsvar max_optimization_goalsvar metric_optimizationvar namevar outcome_measurementvar placementsvar pricing_optionsvar product_cardvar product_card_detailedvar product_idvar publisher_propertiesvar reporting_capabilitiesvar trusted_match
class FieldModel (*args, **kwds)-
Expand source code
class Field1(Enum): product_id = 'product_id' name = 'name' description = 'description' publisher_properties = 'publisher_properties' channels = 'channels' format_ids = 'format_ids' placements = 'placements' delivery_type = 'delivery_type' exclusivity = 'exclusivity' pricing_options = 'pricing_options' forecast = 'forecast' outcome_measurement = 'outcome_measurement' delivery_measurement = 'delivery_measurement' reporting_capabilities = 'reporting_capabilities' creative_policy = 'creative_policy' catalog_types = 'catalog_types' metric_optimization = 'metric_optimization' conversion_tracking = 'conversion_tracking' data_provider_signals = 'data_provider_signals' max_optimization_goals = 'max_optimization_goals' catalog_match = 'catalog_match' collections = 'collections' collection_targeting_allowed = 'collection_targeting_allowed' installments = 'installments' brief_relevance = 'brief_relevance' expires_at = 'expires_at' product_card = 'product_card' product_card_detailed = 'product_card_detailed' enforced_policies = 'enforced_policies' trusted_match = 'trusted_match'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var brief_relevancevar catalog_matchvar catalog_typesvar channelsvar collection_targeting_allowedvar collectionsvar conversion_trackingvar creative_policyvar data_provider_signalsvar delivery_measurementvar delivery_typevar descriptionvar enforced_policiesvar exclusivityvar expires_atvar forecastvar format_idsvar installmentsvar max_optimization_goalsvar metric_optimizationvar namevar outcome_measurementvar placementsvar pricing_optionsvar product_cardvar product_card_detailedvar product_idvar publisher_propertiesvar reporting_capabilitiesvar trusted_match
class GetBrandIdentityField (*args, **kwds)-
Expand source code
class FieldModel(Enum): 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'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var assetsvar colorsvar descriptionvar fontsvar industriesvar keller_typevar logosvar rightsvar taglinevar tonevar visual_guidelinesvar voice_synthesis
class FlatRatePricingOption (**data: Any)-
Expand source code
class FlatRatePricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Flat rate cost. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None parameters: Annotated[ Parameters | None, Field( description='DOOH inventory allocation parameters. Sponsorship and takeover flat_rate options omit this field entirely — only include for digital out-of-home inventory.', title='DoohParameters', ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['flat_rate'], Field(description='Fixed cost regardless of delivery volume') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parameters | Nonevar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['flat_rate']var pricing_option_id : str
Inherited members
class Fonts (**data: Any)-
Expand source code
class Fonts(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) font_urls: Annotated[list[AnyUrl] | None, Field(description='URLs to web font files')] = None primary: Annotated[str | None, Field(description='Primary font family')] = None secondary: Annotated[str | None, Field(description='Secondary font family')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var font_urls : list[pydantic.networks.AnyUrl] | Nonevar model_configvar primary : str | Nonevar secondary : str | None
Inherited members
class ForecastMethod (*args, **kwds)-
Expand source code
class ForecastMethod(Enum): estimate = 'estimate' modeled = 'modeled' guaranteed = 'guaranteed'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var estimatevar guaranteedvar modeled
class ForecastPoint (**data: Any)-
Expand source code
class ForecastPoint(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) budget: Annotated[ float | None, Field( description='Budget amount for this forecast point. Required for spend curves; omit for availability forecasts where the metrics represent total available inventory. For allocation-level forecasts, this is the absolute budget for that allocation (not the percentage). For proposal-level forecasts, this is the total proposal budget. When omitted, use metrics.spend to express the estimated cost of the available inventory.', ge=0.0, ), ] = None metrics: Annotated[ Metrics, Field( description='Forecasted metric values. Keys are forecastable-metric enum values for delivery/engagement or event-type enum values for outcomes. Values are ForecastRange objects (low/mid/high). Use { "mid": value } for point estimates. When budget is present, these are the expected metrics at that spend level. When budget is omitted, these represent total available inventory — use spend to express the estimated cost. Additional keys beyond the documented properties are allowed for event-type values (purchase, lead, app_install, etc.).' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var budget : float | Nonevar metrics : Metricsvar model_config
Inherited members
class ForecastRange (**data: Any)-
Expand source code
class ForecastRange(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) high: Annotated[ float | None, Field(description='Optimistic (high-end) forecast value', ge=0.0) ] = None low: Annotated[ float | None, Field(description='Conservative (low-end) forecast value', ge=0.0) ] = None mid: Annotated[float, Field(description='Expected (most likely) forecast value', ge=0.0)]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var high : float | Nonevar low : float | Nonevar mid : floatvar model_config
Inherited members
class ForecastRangeUnit (*args, **kwds)-
Expand source code
class ForecastRangeUnit(Enum): spend = 'spend' availability = 'availability' reach_freq = 'reach_freq' weekly = 'weekly' daily = 'daily' clicks = 'clicks' conversions = 'conversions'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var availabilityvar clicksvar conversionsvar dailyvar reach_freqvar spendvar weekly
class ForecastableMetric (*args, **kwds)-
Expand source code
class ForecastableMetric(Enum): audience_size = 'audience_size' reach = 'reach' frequency = 'frequency' impressions = 'impressions' clicks = 'clicks' spend = 'spend' views = 'views' completed_views = 'completed_views' grps = 'grps' engagements = 'engagements' follows = 'follows' saves = 'saves' profile_visits = 'profile_visits'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var audience_sizevar clicksvar completed_viewsvar engagementsvar followsvar frequencyvar grpsvar impressionsvar profile_visitsvar reachvar savesvar spendvar views
class Format (**data: Any)-
Expand source code
class Format(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accepts_parameters: Annotated[ list[format_id_parameter.FormatIdParameter] | None, Field( description='List of parameters this format accepts in format_id. Template formats define which parameters (dimensions, duration, etc.) can be specified when instantiating the format. Empty or omitted means this is a concrete format with fixed parameters.' ), ] = None accessibility: Annotated[ Accessibility | None, Field( description='Accessibility posture of this format. Declares the WCAG conformance level that creatives produced by this format will meet.' ), ] = None assets: Annotated[ list[ Assets | Assets5 | Assets6 | Assets7 | Assets8 | Assets9 | Assets10 | Assets11 | Assets12 | Assets13 | Assets14 | Assets15 | Assets16 | Assets17 | Assets18 ] | None, Field( description="Array of all assets supported for this format. Each asset is identified by its asset_id, which must be used as the key in creative manifests. Use the 'required' boolean on each asset to indicate whether it's mandatory." ), ] = None delivery: Annotated[ dict[str, Any] | None, Field(description='Delivery method specifications (e.g., hosted, VAST, third-party tags)'), ] = None description: Annotated[ str | None, Field( description='Plain text explanation of what this format does and what assets it requires' ), ] = None disclosure_capabilities: Annotated[ list[DisclosureCapability] | None, Field( description='Structured disclosure capabilities per position with persistence modes. Declares which persistence behaviors each disclosure position supports, enabling persistence-aware matching against provenance render guidance and brief requirements. When present, supersedes supported_disclosure_positions for persistence-aware queries. The flat supported_disclosure_positions field is retained for backward compatibility. Each position MUST appear at most once; validators and agents SHOULD reject duplicates.', min_length=1, ), ] = None example_url: Annotated[ AnyUrl | None, Field( description='Optional URL to showcase page with examples and interactive demos of this format' ), ] = None format_card: Annotated[ FormatCard | None, Field( description='Optional standard visual card (300x400px) for displaying this format in user interfaces. Can be rendered via preview_creative or pre-generated.' ), ] = None format_card_detailed: Annotated[ FormatCardDetailed | None, Field( description='Optional detailed card with carousel and full specifications. Provides rich format documentation similar to ad spec pages.' ), ] = None format_id: Annotated[ format_id_1.FormatId, Field(description='Structured format identifier with agent URL and format name'), ] input_format_ids: Annotated[ list[format_id_1.FormatId] | None, Field( description='Array of format IDs this format accepts as input creative manifests. When present, indicates this format can take existing creatives in these formats as input. Omit for formats that work from raw assets (images, text, etc.) rather than existing creatives.' ), ] = None name: Annotated[str, Field(description='Human-readable format name')] output_format_ids: Annotated[ list[format_id_1.FormatId] | None, Field( description='Array of format IDs that this format can produce as output. When present, indicates this format can build creatives in these output formats (e.g., a multi-publisher template format might produce standard display formats across many publishers). Omit for formats that produce a single fixed output (the format itself).' ), ] = None renders: Annotated[ list[Renders | Renders1] | None, Field( description='Specification of rendered pieces for this format. Most formats produce a single render. Companion ad formats (video + banner), adaptive formats, and multi-placement formats produce multiple renders. Each render specifies its role and dimensions.', min_length=1, ), ] = None reported_metrics: Annotated[ list[available_metric.AvailableMetric] | None, Field( description='Metrics this format can produce in delivery reporting. Buyers receive the intersection of format reported_metrics and product available_metrics. If omitted, the format defers entirely to product-level metric declarations.', min_length=1, ), ] = None supported_disclosure_positions: Annotated[ list[disclosure_position.DisclosurePosition] | None, Field( description='Disclosure positions this format can render. Buyers use this to determine whether a format can satisfy their compliance requirements before submitting a creative. When omitted, the format makes no disclosure rendering guarantees — creative agents SHOULD treat this as incompatible with briefs that require specific disclosure positions. Values correspond to positions on creative-brief.json required_disclosures.', min_length=1, ), ] = None supported_macros: Annotated[ list[universal_macro.UniversalMacro | str] | None, Field( description='List of universal macros supported by this format (e.g., MEDIA_BUY_ID, CACHEBUSTER, DEVICE_ID). Used for validation and developer tooling. See docs/creative/universal-macros.mdx for full documentation.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accepts_parameters : list[FormatIdParameter] | Nonevar accessibility : Accessibility | Nonevar assets : list[Assets | Assets5 | Assets6 | Assets7 | Assets8 | Assets9 | Assets10 | Assets11 | Assets12 | Assets13 | Assets14 | Assets15 | Assets16 | Assets17 | Assets18] | Nonevar delivery : dict[str, typing.Any] | Nonevar description : str | Nonevar disclosure_capabilities : list[DisclosureCapability] | Nonevar example_url : pydantic.networks.AnyUrl | Nonevar format_card : FormatCard | Nonevar format_card_detailed : FormatCardDetailed | Nonevar format_id : FormatIdvar input_format_ids : list[FormatId] | Nonevar model_configvar name : strvar output_format_ids : list[FormatId] | Nonevar renders : list[Renders | Renders1] | Nonevar reported_metrics : list[AvailableMetric] | Nonevar supported_disclosure_positions : list[DisclosurePosition] | Nonevar supported_macros : list[UniversalMacro | str] | None
Inherited members
class FormatCard (**data: Any)-
Expand source code
class FormatCard(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) format_id: Annotated[ format_id_1.FormatId, Field( description='Creative format defining the card layout (typically format_card_standard)' ), ] manifest: Annotated[ dict[str, Any], Field(description='Asset manifest for rendering the card, structure defined by the format'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var format_id : FormatIdvar manifest : dict[str, typing.Any]var model_config
Inherited members
class FormatCardDetailed (**data: Any)-
Expand source code
class FormatCardDetailed(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) format_id: Annotated[ format_id_1.FormatId, Field( description='Creative format defining the detailed card layout (typically format_card_detailed)' ), ] manifest: Annotated[ dict[str, Any], Field( description='Asset manifest for rendering the detailed card, structure defined by the format' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var format_id : FormatIdvar manifest : dict[str, typing.Any]var model_config
Inherited members
class FormatId (**data: Any)-
Expand source code
class FormatId(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) agent_url: Annotated[ AnyUrl, Field( description="URL of the agent that defines this format (e.g., 'https://creatives.adcontextprotocol.org' for standard formats, or 'https://publisher.com/.well-known/adcp/sales' for custom formats)" ), ] duration_ms: Annotated[ float | None, Field( description='Duration in milliseconds for time-based formats (video, audio). When specified, creates a parameterized format ID. Omit to reference a template format without parameters.', ge=1.0, ), ] = None height: Annotated[ int | None, Field( description='Height in pixels for visual formats. When specified, width must also be specified. Both fields together create a parameterized format ID for dimension-specific variants.', ge=1, ), ] = None id: Annotated[ str, Field( description="Format identifier within the agent's namespace (e.g., 'display_static', 'video_hosted', 'audio_standard'). When used alone, references a template format. When combined with dimension/duration fields, creates a parameterized format ID for a specific variant.", pattern='^[a-zA-Z0-9_-]+$', ), ] width: Annotated[ int | None, Field( description='Width in pixels for visual formats. When specified, height must also be specified. Both fields together create a parameterized format ID for dimension-specific variants.', ge=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var agent_url : pydantic.networks.AnyUrlvar duration_ms : float | Nonevar height : int | Nonevar id : strvar model_configvar width : int | None
Inherited members
class FormatIdParameter (*args, **kwds)-
Expand source code
class FormatIdParameter(Enum): dimensions = 'dimensions' duration = 'duration'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dimensionsvar duration
class FrequencyCap (**data: Any)-
Expand source code
class FrequencyCap(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) max_impressions: Annotated[ int | None, Field( description="Maximum number of impressions per entity per window. For duration windows, implementations typically use a rolling window; 'campaign' applies a fixed cap across the full flight.", ge=1, ), ] = None per: Annotated[ reach_unit.ReachUnit | None, Field( description='Entity granularity for impression counting. Required when max_impressions is set.' ), ] = None suppress: Annotated[ duration.Duration | None, Field( description='Cooldown period between consecutive exposures to the same entity. Prevents back-to-back ad delivery (e.g. {"interval": 60, "unit": "minutes"} for a 1-hour cooldown). Preferred over suppress_minutes.' ), ] = None suppress_minutes: Annotated[ float | None, Field( description='Deprecated — use suppress instead. Cooldown period in minutes between consecutive exposures to the same entity (e.g. 60 for a 1-hour cooldown).', ge=0.0, ), ] = None window: Annotated[ duration.Duration | None, Field( description='Time window for the max_impressions cap (e.g. {"interval": 7, "unit": "days"} or {"interval": 1, "unit": "campaign"} for the full flight). Required when max_impressions is set.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var max_impressions : int | Nonevar model_configvar per : ReachUnit | Nonevar suppress : Duration | Nonevar suppress_minutes : float | Nonevar window : Duration | None
Inherited members
class FrequencyCapScope (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class FrequencyCapScope(RootModel[Literal['package']]): root: Annotated[ Literal['package'], Field(description='Scope for frequency cap application', title='Frequency Cap Scope'), ]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Literal['package']]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : Literal['package']
class GeoCountry (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class GeoCountry(RootModel[str]): root: Annotated[str, Field(pattern='^[A-Z]{2}$')]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Subclasses
Class variables
var model_configvar root : str
class GeoMetro (**data: Any)-
Expand source code
class GeoMetro(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) system: Annotated[ metro_system.MetroAreaSystem, Field(description="Metro area classification system (e.g., 'nielsen_dma', 'uk_itl2')"), ] values: Annotated[ list[str], Field( description="Metro codes within the system (e.g., ['501', '602'] for Nielsen DMAs)", min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar system : MetroAreaSystemvar values : list[str]
Inherited members
class GeoPostalArea (**data: Any)-
Expand source code
class GeoPostalArea(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) system: Annotated[ postal_system.PostalCodeSystem, Field( description="Postal code system (e.g., 'us_zip', 'gb_outward'). System name encodes country and precision." ), ] values: Annotated[ list[str], Field( description="Postal codes within the system (e.g., ['10001', '10002'] for us_zip)", min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar system : PostalCodeSystemvar values : list[str]
Inherited members
class GeoRegion (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class GeoRegion(RootModel[str]): root: Annotated[str, Field(pattern='^[A-Z]{2}-[A-Z0-9]{1,3}$')]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Subclasses
Class variables
var model_configvar root : str
class GetAccountFinancialsRequest (**data: Any)-
Expand source code
class GetAccountFinancialsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account to query financials for. Must be an operator-billed account.'), ] context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None period: Annotated[ date_range.DateRange | None, Field( description='Date range for the spend summary. Defaults to the current billing cycle if omitted.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar period : DateRange | None
Inherited members
class GetAccountFinancialsSuccessResponse (**data: Any)-
Expand source code
class GetAccountFinancialsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account reference, echoed from the request'), ] balance: Annotated[ Balance | None, Field(description='Prepay balance. Present for prepay accounts.') ] = None context: context_1.ContextObject | None = None credit: Annotated[ Credit | None, Field( description='Credit status. Present for credit-based accounts (payment_terms like net_30).' ), ] = None currency: Annotated[ str, Field( description='ISO 4217 currency code for all monetary amounts in this response', pattern='^[A-Z]{3}$', ), ] ext: ext_1.ExtensionObject | None = None invoices: Annotated[ list[Invoice] | None, Field(description='Recent invoices. Sellers may limit the number returned.'), ] = None payment_status: Annotated[ PaymentStatus | None, Field( description='Overall payment status. current: all obligations met. past_due: one or more invoices overdue. suspended: account suspended due to payment issues.' ), ] = None payment_terms: Annotated[ PaymentTerms | None, Field(description='Payment terms in effect for this account') ] = None period: Annotated[ date_range.DateRange, Field( description='The actual period covered by spend data. May differ from the requested period if the seller adjusts to billing cycle boundaries.' ), ] spend: Annotated[Spend | None, Field(description='Spend summary for the period')] = None timezone: Annotated[ str, Field( description="IANA timezone of the seller's billing day boundaries (e.g., 'America/New_York'). All dates in this response — period, invoice periods, due dates — are calendar dates in this timezone. Buyers in a different timezone should expect spend boundaries to differ from their own calendar day." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar balance : Balance | Nonevar context : ContextObject | Nonevar credit : Credit | Nonevar currency : strvar ext : ExtensionObject | Nonevar invoices : list[Invoice] | Nonevar model_configvar payment_status : PaymentStatus | Nonevar payment_terms : PaymentTerms | Nonevar period : DateRangevar spend : Spend | Nonevar timezone : str
Inherited members
class GetAccountFinancialsErrorResponse (**data: Any)-
Expand source code
class GetAccountFinancialsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[list[error.Error], Field(description='Operation-level errors', min_length=1)] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetAdcpCapabilitiesRequest (**data: Any)-
Expand source code
class GetAdcpCapabilitiesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None protocols: Annotated[ list[Protocol] | None, Field( description='Specific protocols to query capabilities for. If omitted, returns capabilities for all supported protocols.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar protocols : list[Protocol] | None
Inherited members
class GetAdcpCapabilitiesResponse (**data: Any)-
Expand source code
class GetAdcpCapabilitiesResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ Account | None, Field( description='Account management capabilities. Describes how accounts are established, what billing models are supported, and whether an account is required before browsing products.' ), ] = None adcp: Annotated[Adcp, Field(description='Core AdCP protocol information')] brand: Annotated[ Brand | None, Field( description='Brand protocol capabilities. Only present if brand is in supported_protocols. Brand agents provide identity data (logos, colors, tone, assets) and optionally rights clearance for licensable content (talent, music, stock media).' ), ] = None context: context_1.ContextObject | None = None creative: Annotated[ Creative | None, Field( description='Creative protocol capabilities. Only present if creative is in supported_protocols.' ), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None ext: ext_1.ExtensionObject | None = None extensions_supported: Annotated[ list[ExtensionsSupportedItem] | None, Field( description='Extension namespaces this agent supports. Buyers can expect meaningful data in ext.{namespace} fields on responses from this agent. Extension schemas are published in the AdCP extension registry.' ), ] = None governance: Annotated[ Governance | None, Field( description='Governance protocol capabilities. Only present if governance is in supported_protocols. Governance agents provide property and creative data like compliance scores, brand safety ratings, sustainability metrics, and creative quality assessments.' ), ] = None last_updated: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp of when capabilities were last updated. Buyers can use this for cache invalidation.' ), ] = None media_buy: Annotated[ MediaBuy | None, Field( description='Media-buy protocol capabilities. Only present if media_buy is in supported_protocols.' ), ] = None signals: Annotated[ Signals | None, Field( description='Signals protocol capabilities. Only present if signals is in supported_protocols.' ), ] = None sponsored_intelligence: Annotated[ SponsoredIntelligence | None, Field( description='Sponsored Intelligence protocol capabilities. Only present if sponsored_intelligence is in supported_protocols. SI agents handle conversational brand experiences.' ), ] = None supported_protocols: Annotated[ list[SupportedProtocol], Field(description='Which AdCP domain protocols this seller supports', min_length=1), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : Account | Nonevar adcp : Adcpvar brand : Brand | Nonevar context : ContextObject | Nonevar creative : Creative | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar extensions_supported : list[ExtensionsSupportedItem] | Nonevar governance : Governance | Nonevar last_updated : pydantic.types.AwareDatetime | Nonevar media_buy : MediaBuy | Nonevar model_configvar signals : Signals | Nonevar sponsored_intelligence : SponsoredIntelligence | Nonevar supported_protocols : list[SupportedProtocol]
Inherited members
class GetBrandIdentityRequest (**data: Any)-
Expand source code
class GetBrandIdentityRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand_id: Annotated[str, Field(description='Brand identifier from brand.json brands array')] context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[FieldModel] | 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." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand_id : strvar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[FieldModel] | Nonevar model_configvar use_case : str | None
Inherited members
class GetBrandIdentitySuccessResponse (**data: Any)-
Expand source code
class GetBrandIdentityResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assets: Annotated[ list[Asset] | None, Field( description='Available brand assets (images, audio, video). Authorized callers only. Shape matches brand.json asset definition.' ), ] = None available_fields: Annotated[ list[AvailableField] | None, Field( description='Fields available but not returned in this response due to authorization level. Tells the caller what they would gain by linking their account via sync_accounts. Values match the request fields enum.' ), ] = None brand_id: Annotated[str, Field(description='Brand identifier')] colors: Annotated[ Colors | None, Field( description='Brand color palette. Each role accepts a single hex color or an array of hex colors. Shape matches brand.json colors definition.' ), ] = None context: context_1.ContextObject | None = None description: Annotated[str | None, Field(description='Brand description')] = None ext: ext_1.ExtensionObject | None = None fonts: Annotated[ Fonts | None, Field(description='Brand typography. Shape matches brand.json fonts definition.'), ] = None house: Annotated[ House, Field( description='The house (corporate entity) this brand belongs to. Always returned regardless of authorization level.' ), ] industries: Annotated[ list[str] | None, Field(description='Brand industries.', 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='Brand logos. Public callers get standard logos; authorized callers also receive high-res variants. Shape matches brand.json logo definition.' ), ] = None names: Annotated[ list[dict[str, str]], Field( description="Localized brand names with BCP 47 locale code keys (e.g., 'en_US', 'fr_CA'). Bare language codes ('en') are accepted as wildcards for backwards compatibility." ), ] rights: Annotated[ Rights | None, Field(description='Rights availability summary. For detailed pricing, use get_rights.'), ] = None tagline: Annotated[ str | Tagline | None, Field( description='Brand tagline or slogan. Accepts a plain string or a localized array matching the names pattern.' ), ] = None tone: Annotated[Tone | None, Field(description='Brand voice and messaging guidelines')] = None visual_guidelines: Annotated[ dict[str, Any] | None, Field( description='Structured visual rules for generative creative systems (photography, graphic_style, colorways, type_scale, motion). Matches brand.json visual_guidelines definition. Authorized callers only.' ), ] = None voice_synthesis: Annotated[ VoiceSynthesis | None, Field(description='Voice synthesis configuration for AI-generated audio'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assets : list[Asset] | Nonevar available_fields : list[AvailableField] | Nonevar brand_id : strvar colors : Colors | Nonevar context : ContextObject | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar fonts : Fonts | Nonevar house : Housevar industries : list[str] | Nonevar keller_type : KellerType | Nonevar logos : list[Logo] | Nonevar model_configvar names : list[dict[str, str]]var rights : Rights | Nonevar tagline : str | Tagline | Nonevar tone : Tone | Nonevar visual_guidelines : dict[str, typing.Any] | Nonevar voice_synthesis : VoiceSynthesis | None
Inherited members
class GetBrandIdentityErrorResponse (**data: Any)-
Expand source code
class GetBrandIdentityResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[list[error.Error], Field(min_length=1)] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetContentStandardsRequest (**data: Any)-
Expand source code
class GetContentStandardsRequest(AdCPBaseModel): context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None standards_id: Annotated[ str, Field(description='Identifier for the standards configuration to retrieve') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar standards_id : str
Inherited members
class GetContentStandardsSuccessResponse (**data: Any)-
Expand source code
class GetContentStandardsResponse1(ContentStandards): context: context_1.ContextObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- ContentStandards
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar model_config
Inherited members
class GetContentStandardsErrorResponse (**data: Any)-
Expand source code
class GetContentStandardsResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetCreativeDeliveryRequest (**data: Any)-
Expand source code
class GetCreativeDeliveryRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for routing and scoping. Limits results to creatives within this account.' ), ] = None context: context_1.ContextObject | None = None creative_ids: Annotated[ list[str] | None, Field( description='Filter to specific creatives by ID. If omitted, returns delivery for all creatives matching the other filters.', min_length=1, ), ] = None end_date: Annotated[ str | None, Field( description="End date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None ext: ext_1.ExtensionObject | None = None max_variants: Annotated[ int | None, Field( description='Maximum number of variants to return per creative. When omitted, the agent returns all variants. Use this to limit response size for generative creatives that may produce large numbers of variants.', ge=1, ), ] = None media_buy_ids: Annotated[ list[str] | None, Field( description='Filter to specific media buys by publisher ID. If omitted, returns creative delivery across all matching media buys.', min_length=1, ), ] = None pagination: Annotated[ pagination_request.PaginationRequest | None, Field( description='Pagination parameters for the creatives array in the response. Uses cursor-based pagination consistent with other list operations.' ), ] = None start_date: Annotated[ str | None, Field( description="Start date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_ids : list[str] | Nonevar model_configvar pagination : PaginationRequest | Nonevar start_date : str | None
class GetCreativeDeliveryByBuyerRefRequest (**data: Any)-
Expand source code
class GetCreativeDeliveryRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for routing and scoping. Limits results to creatives within this account.' ), ] = None context: context_1.ContextObject | None = None creative_ids: Annotated[ list[str] | None, Field( description='Filter to specific creatives by ID. If omitted, returns delivery for all creatives matching the other filters.', min_length=1, ), ] = None end_date: Annotated[ str | None, Field( description="End date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None ext: ext_1.ExtensionObject | None = None max_variants: Annotated[ int | None, Field( description='Maximum number of variants to return per creative. When omitted, the agent returns all variants. Use this to limit response size for generative creatives that may produce large numbers of variants.', ge=1, ), ] = None media_buy_ids: Annotated[ list[str] | None, Field( description='Filter to specific media buys by publisher ID. If omitted, returns creative delivery across all matching media buys.', min_length=1, ), ] = None pagination: Annotated[ pagination_request.PaginationRequest | None, Field( description='Pagination parameters for the creatives array in the response. Uses cursor-based pagination consistent with other list operations.' ), ] = None start_date: Annotated[ str | None, Field( description="Start date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_ids : list[str] | Nonevar model_configvar pagination : PaginationRequest | Nonevar start_date : str | None
class GetCreativeDeliveryByCreativeRequest (**data: Any)-
Expand source code
class GetCreativeDeliveryRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for routing and scoping. Limits results to creatives within this account.' ), ] = None context: context_1.ContextObject | None = None creative_ids: Annotated[ list[str] | None, Field( description='Filter to specific creatives by ID. If omitted, returns delivery for all creatives matching the other filters.', min_length=1, ), ] = None end_date: Annotated[ str | None, Field( description="End date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None ext: ext_1.ExtensionObject | None = None max_variants: Annotated[ int | None, Field( description='Maximum number of variants to return per creative. When omitted, the agent returns all variants. Use this to limit response size for generative creatives that may produce large numbers of variants.', ge=1, ), ] = None media_buy_ids: Annotated[ list[str] | None, Field( description='Filter to specific media buys by publisher ID. If omitted, returns creative delivery across all matching media buys.', min_length=1, ), ] = None pagination: Annotated[ pagination_request.PaginationRequest | None, Field( description='Pagination parameters for the creatives array in the response. Uses cursor-based pagination consistent with other list operations.' ), ] = None start_date: Annotated[ str | None, Field( description="Start date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_ids : list[str] | Nonevar model_configvar pagination : PaginationRequest | Nonevar start_date : str | None
class GetCreativeDeliveryByMediaBuyRequest (**data: Any)-
Expand source code
class GetCreativeDeliveryRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for routing and scoping. Limits results to creatives within this account.' ), ] = None context: context_1.ContextObject | None = None creative_ids: Annotated[ list[str] | None, Field( description='Filter to specific creatives by ID. If omitted, returns delivery for all creatives matching the other filters.', min_length=1, ), ] = None end_date: Annotated[ str | None, Field( description="End date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None ext: ext_1.ExtensionObject | None = None max_variants: Annotated[ int | None, Field( description='Maximum number of variants to return per creative. When omitted, the agent returns all variants. Use this to limit response size for generative creatives that may produce large numbers of variants.', ge=1, ), ] = None media_buy_ids: Annotated[ list[str] | None, Field( description='Filter to specific media buys by publisher ID. If omitted, returns creative delivery across all matching media buys.', min_length=1, ), ] = None pagination: Annotated[ pagination_request.PaginationRequest | None, Field( description='Pagination parameters for the creatives array in the response. Uses cursor-based pagination consistent with other list operations.' ), ] = None start_date: Annotated[ str | None, Field( description="Start date for delivery period (YYYY-MM-DD). Interpreted in the platform's reporting timezone.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_ids : list[str] | Nonevar model_configvar pagination : PaginationRequest | Nonevar start_date : str | None
Inherited members
class GetCreativeDeliveryResponse (**data: Any)-
Expand source code
class GetCreativeDeliveryResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account_id: Annotated[ str | None, Field( description='Account identifier. Present when the response spans or is scoped to a specific account.' ), ] = None context: context_1.ContextObject | None = None creatives: Annotated[ list[Creative], Field(description='Creative delivery data with variant breakdowns') ] currency: Annotated[ str, Field( description="ISO 4217 currency code for monetary values in this response (e.g., 'USD', 'EUR')", pattern='^[A-Z]{3}$', ), ] errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None ext: ext_1.ExtensionObject | None = None media_buy_id: Annotated[ str | None, Field( description="Publisher's media buy identifier. Present when the request was scoped to a single media buy." ), ] = None pagination: Annotated[ Pagination | None, Field( description='Pagination information. Present when the request included pagination parameters.' ), ] = None reporting_period: Annotated[ReportingPeriod, Field(description='Date range for the report.')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account_id : str | Nonevar context : ContextObject | Nonevar creatives : list[Creative]var currency : strvar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar media_buy_id : str | Nonevar model_configvar pagination : Pagination | Nonevar reporting_period : ReportingPeriod
Inherited members
class GetCreativeFeaturesRequest (**data: Any)-
Expand source code
class GetCreativeFeaturesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for billing this evaluation. Required when the governance agent charges per evaluation.' ), ] = None context: context_1.ContextObject | None = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='The creative manifest to evaluate. Contains format_id and assets.'), ] ext: ext_1.ExtensionObject | None = None feature_ids: Annotated[ list[str] | None, Field( description='Optional filter to specific features. If omitted, returns all available features.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar creative_manifest : CreativeManifestvar ext : ExtensionObject | Nonevar feature_ids : list[str] | Nonevar model_config
Inherited members
class GetCreativeFeaturesSuccessResponse (**data: Any)-
Expand source code
class GetCreativeFeaturesResponse1(AdCPBaseModel): context: context_1.ContextObject | None = None detail_url: Annotated[ AnyUrl | None, Field( description="URL to the vendor's full assessment report. The vendor controls what information is disclosed and access control." ), ] = None ext: ext_1.ExtensionObject | None = None results: Annotated[ list[creative_feature_result.CreativeFeatureResult], Field(description='Feature values for the evaluated creative'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar detail_url : pydantic.networks.AnyUrl | Nonevar ext : ExtensionObject | Nonevar model_configvar results : list[CreativeFeatureResult]
Inherited members
class GetCreativeFeaturesErrorResponse (**data: Any)-
Expand source code
class GetCreativeFeaturesResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetMediaBuyArtifactsRequest (**data: Any)-
Expand source code
class GetMediaBuyArtifactsRequest(AdCPBaseModel): account: Annotated[ account_ref.AccountReference | None, Field( description='Filter artifacts to a specific account. When omitted, returns artifacts across all accessible accounts.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None failures_only: Annotated[ bool | None, Field( description="When true, only return artifacts where the seller's local model returned local_verdict: 'fail'. Useful for auditing false positives. Not useful when the seller does not run a local evaluation model (all verdicts are 'unevaluated')." ), ] = False media_buy_id: Annotated[str, Field(description='Media buy to get artifacts from')] package_ids: Annotated[ list[str] | None, Field(description='Filter to specific packages within the media buy', min_length=1), ] = None pagination: Annotated[ Pagination | None, Field( description='Pagination parameters. Uses higher limits than standard pagination because artifact result sets can be very large.' ), ] = None time_range: Annotated[TimeRange | None, Field(description='Filter to specific time period')] = ( None )Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar failures_only : bool | Nonevar media_buy_id : strvar model_configvar package_ids : list[str] | Nonevar pagination : Pagination | Nonevar time_range : TimeRange | None
Inherited members
class GetMediaBuyArtifactsSuccessResponse (**data: Any)-
Expand source code
class GetMediaBuyArtifactsResponse1(AdCPBaseModel): artifacts: Annotated[ list[Artifact], Field(description='Delivery records with full artifact content') ] collection_info: Annotated[ CollectionInfo | None, Field( description='Information about artifact collection for this media buy. Sampling is configured at buy creation time — this reports what was actually collected.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None media_buy_id: Annotated[str, Field(description='Media buy these artifacts belong to')] pagination: pagination_response.PaginationResponse | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var artifacts : list[Artifact]var collection_info : CollectionInfo | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar pagination : PaginationResponse | None
Inherited members
class GetMediaBuyArtifactsErrorResponse (**data: Any)-
Expand source code
class GetMediaBuyArtifactsResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetMediaBuyDeliveryRequest (**data: Any)-
Expand source code
class GetMediaBuyDeliveryRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Filter delivery data to a specific account. When omitted, returns data across all accessible accounts.' ), ] = None attribution_window: Annotated[ AttributionWindow | None, Field( description='Attribution window to apply for conversion metrics. When provided, the seller returns conversion data using the requested lookback windows instead of their platform default. The seller echoes the applied window in the response. Sellers that do not support configurable windows ignore this field and return their default. Check get_adcp_capabilities conversion_tracking.attribution_windows for available options.' ), ] = None context: context_1.ContextObject | None = None end_date: Annotated[ str | None, Field( description="End date for reporting period (YYYY-MM-DD). When omitted along with start_date, returns campaign lifetime data. Only accepted when the product's reporting_capabilities.date_range_support is 'date_range'.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None ext: ext_1.ExtensionObject | None = None include_package_daily_breakdown: Annotated[ bool | None, Field( description='When true, include daily_breakdown arrays within each package in by_package. Useful for per-package pacing analysis and line-item monitoring. Omit or set false to reduce response size — package daily data can be large for multi-package buys over long flights.' ), ] = False media_buy_ids: Annotated[ list[str] | None, Field(description='Array of media buy IDs to get delivery data for', min_length=1), ] = None reporting_dimensions: Annotated[ ReportingDimensions | None, Field( description='Request dimensional breakdowns in delivery reporting. Each key enables a specific breakdown dimension within by_package — include as an empty object (e.g., "device_type": {}) to activate with defaults. Omit entirely for no breakdowns (backward compatible). Unsupported dimensions are silently omitted from the response. Note: keyword, catalog_item, and creative breakdowns are returned automatically when the seller supports them and are not controlled by this object.' ), ] = None start_date: Annotated[ str | None, Field( description="Start date for reporting period (YYYY-MM-DD). When omitted along with end_date, returns campaign lifetime data. Only accepted when the product's reporting_capabilities.date_range_support is 'date_range'.", pattern='^\\d{4}-\\d{2}-\\d{2}$', ), ] = None status_filter: Annotated[ media_buy_status.MediaBuyStatus | StatusFilter | None, Field(description='Filter by status. Can be a single status or array of statuses'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar attribution_window : AttributionWindow | Nonevar context : ContextObject | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar include_package_daily_breakdown : bool | Nonevar media_buy_ids : list[str] | Nonevar model_configvar reporting_dimensions : ReportingDimensions | Nonevar start_date : str | Nonevar status_filter : MediaBuyStatus | StatusFilter | None
Inherited members
class GetMediaBuyDeliveryResponse (**data: Any)-
Expand source code
class GetMediaBuyDeliveryResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) aggregated_totals: Annotated[ AggregatedTotals | None, Field( description='Combined metrics across all returned media buys. Only included in API responses (get_media_buy_delivery), not in webhook notifications.' ), ] = None attribution_window: Annotated[ attribution_window_1.AttributionWindow | None, Field( description='Attribution methodology and lookback windows used for conversion metrics in this response. All media buys from a single seller share the same attribution methodology. Enables cross-platform comparison (e.g., Amazon 14-day click vs. Criteo 30-day click).' ), ] = None context: context_1.ContextObject | None = None currency: Annotated[str, Field(description='ISO 4217 currency code', pattern='^[A-Z]{3}$')] errors: Annotated[ list[error.Error] | None, Field( description='Task-specific errors and warnings (e.g., missing delivery data, reporting platform issues)' ), ] = None ext: ext_1.ExtensionObject | None = None media_buy_deliveries: Annotated[ list[MediaBuyDelivery], Field( description='Array of delivery data for media buys. When used in webhook notifications, may contain multiple media buys aggregated by publisher. When used in get_media_buy_delivery API responses, typically contains requested media buys.' ), ] next_expected_at: Annotated[ AwareDatetime | None, Field( description="ISO 8601 timestamp for next expected notification (only present in webhook deliveries when notification_type is not 'final')" ), ] = None notification_type: Annotated[ NotificationType | None, Field( description='Type of webhook notification (only present in webhook deliveries): scheduled = regular periodic update, final = campaign completed, delayed = data not yet available, adjusted = resending period with updated data' ), ] = None partial_data: Annotated[ bool | None, Field( description='Indicates if any media buys in this webhook have missing/delayed data (only present in webhook deliveries)' ), ] = None reporting_period: Annotated[ ReportingPeriod, Field(description='Date range for the report. All periods use UTC timezone.'), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None sequence_number: Annotated[ int | None, Field( description='Sequential notification number (only present in webhook deliveries, starts at 1)', ge=1, ), ] = None unavailable_count: Annotated[ int | None, Field( description='Number of media buys with reporting_delayed or failed status (only present in webhook deliveries when partial_data is true)', ge=0, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var aggregated_totals : AggregatedTotals | Nonevar attribution_window : AttributionWindow | Nonevar context : ContextObject | Nonevar currency : strvar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar media_buy_deliveries : list[MediaBuyDelivery]var model_configvar next_expected_at : pydantic.types.AwareDatetime | Nonevar notification_type : NotificationType | Nonevar partial_data : bool | Nonevar reporting_period : ReportingPeriodvar sandbox : bool | Nonevar sequence_number : int | None
Inherited members
class GetMediaBuysRequest (**data: Any)-
Expand source code
class GetMediaBuysRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account to retrieve media buys for. When omitted, returns data across all accessible accounts.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None include_history: Annotated[ int | None, Field( description='When present, include the last N revision history entries for each media buy (returns min(N, available entries)). Each entry contains revision number, timestamp, actor, and a summary of what changed. Omit or set to 0 to exclude history (default). Recommended: 5-10 for monitoring, 50+ for audit.', ge=0, le=1000, ), ] = 0 include_snapshot: Annotated[ bool | None, Field( description='When true, include a near-real-time delivery snapshot for each package. Snapshots reflect the latest available entity-level stats from the platform (e.g., updated every ~15 minutes on GAM, ~1 hour on batch-only platforms). The staleness_seconds field on each snapshot indicates data freshness. If a snapshot cannot be returned, package.snapshot_unavailable_reason explains why. Defaults to false.' ), ] = False media_buy_ids: Annotated[ list[str] | None, Field( description='Array of media buy IDs to retrieve. When omitted, returns a paginated set of accessible media buys matching status_filter.', min_length=1, ), ] = None pagination: Annotated[ pagination_request.PaginationRequest | None, Field( description='Cursor-based pagination controls. Strongly recommended when querying broad scopes (for example, all active media buys in an account).' ), ] = None status_filter: Annotated[ media_buy_status.MediaBuyStatus | StatusFilter | None, Field( description='Filter by status. Can be a single status or array of statuses. Defaults to ["active"] when media_buy_ids is omitted. When media_buy_ids is provided, no implicit status filter is applied.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar include_history : int | Nonevar include_snapshot : bool | Nonevar media_buy_ids : list[str] | Nonevar model_configvar pagination : PaginationRequest | Nonevar status_filter : MediaBuyStatus | StatusFilter | None
Inherited members
class GetMediaBuysResponse (**data: Any)-
Expand source code
class GetMediaBuysResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors (e.g., media buy not found)'), ] = None ext: ext_1.ExtensionObject | None = None media_buys: Annotated[ list[MediaBuy], Field( description='Array of media buys with status, creative approval state, and optional delivery snapshots' ), ] pagination: Annotated[ pagination_response.PaginationResponse | None, Field(description='Pagination metadata for the media_buys array.'), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar media_buys : list[MediaBuy]var model_configvar pagination : PaginationResponse | Nonevar sandbox : bool | None
Inherited members
class GetPlanAuditLogsRequest (**data: Any)-
Expand source code
class GetPlanAuditLogsRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) include_entries: Annotated[ bool | None, Field(description='Include the full audit trail. Default: false.') ] = False plan_ids: Annotated[ list[str] | None, Field( description='Plan IDs to retrieve. For a single plan, pass a one-element array.', min_length=1, ), ] = None portfolio_plan_ids: Annotated[ list[str] | None, Field( description='Portfolio plan IDs. The governance agent expands each to its member_plan_ids and returns combined audit data.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var include_entries : bool | Nonevar model_configvar plan_ids : list[str] | Nonevar portfolio_plan_ids : list[str] | None
Inherited members
class GetPlanAuditLogsResponse (**data: Any)-
Expand source code
class GetPlanAuditLogsResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) plans: Annotated[list[Plan], Field(description='Audit data for each requested plan.')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar plans : list[Plan]
Inherited members
class GetProductsRequest (**data: Any)-
Expand source code
class GetProductsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None brief: Annotated[ str | None, Field( description="Natural language description of campaign requirements. Required when buying_mode is 'brief'. Must not be provided when buying_mode is 'wholesale' or 'refine'." ), ] = None buying_mode: Annotated[ BuyingMode, Field( description="Declares buyer intent for this request. 'brief': publisher curates product recommendations from the provided brief. 'wholesale': buyer requests raw inventory to apply their own audiences — brief must not be provided, and proposals are omitted. 'refine': iterate on products and proposals from a previous get_products response using the refine array of change requests. v3 clients MUST include buying_mode. Sellers receiving requests from pre-v3 clients without buying_mode SHOULD default to 'brief'." ), ] catalog: Annotated[ catalog_1.Catalog | None, Field( description='Catalog of items the buyer wants to promote. The seller matches catalog items against its inventory and returns products where matches exist. Supports all catalog types: a job catalog finds job ad products, a product catalog finds sponsored product slots. Reference a synced catalog by catalog_id, or provide inline items.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[Field1] | None, Field( description='Specific product fields to include in the response. When omitted, all fields are returned. Use for lightweight discovery calls where only a subset of product data is needed (e.g., just IDs and pricing for comparison). Required fields (product_id, name) are always included regardless of selection.', min_length=1, ), ] = None filters: product_filters.ProductFilters | None = None pagination: pagination_request.PaginationRequest | None = None preferred_delivery_types: Annotated[ list[delivery_type_1.DeliveryType] | None, Field( description='Delivery types the buyer prefers, in priority order. Unlike filters.delivery_type which excludes non-matching products, this signals preference for curation — the publisher may still include other delivery types when they match the brief well.', min_length=1, ), ] = None property_list: Annotated[ property_list_ref.PropertyListReference | None, Field( description='[AdCP 3.0] Reference to an externally managed property list. When provided, the sales agent should filter products to only those available on properties in the list.' ), ] = None refine: Annotated[ list[Refine | Refine1 | Refine2] | None, Field( description="Array of change requests for iterating on products and proposals from a previous get_products response. Each entry declares a scope (request, product, or proposal) and what the buyer is asking for. Only valid when buying_mode is 'refine'. The seller responds to each entry via refinement_applied in the response, matched by position.", min_length=1, ), ] = None required_policies: Annotated[ list[str] | None, Field( description='Registry policy IDs that the buyer requires to be enforced for products in this response. Sellers filter products to only those that comply with or already enforce the requested policies.' ), ] = None time_budget: Annotated[ duration.Duration | None, Field( description='Maximum time the buyer will commit to this request. The seller returns the best results achievable within this budget and does not start processes (human approvals, expensive external queries) that cannot complete in time. When omitted, the seller decides timing.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar brand : BrandReference | Nonevar brief : str | Nonevar buying_mode : BuyingMode | Nonevar catalog : Catalog | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[Field1] | Nonevar filters : ProductFilters | Nonevar model_configvar pagination : PaginationRequest | Nonevar preferred_delivery_types : list[DeliveryType] | Nonevar property_list : PropertyListReference | Nonevar refine : list[Refine | Refine1 | Refine2] | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
class GetProductsBriefRequest (**data: Any)-
Expand source code
class GetProductsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None brief: Annotated[ str | None, Field( description="Natural language description of campaign requirements. Required when buying_mode is 'brief'. Must not be provided when buying_mode is 'wholesale' or 'refine'." ), ] = None buying_mode: Annotated[ BuyingMode, Field( description="Declares buyer intent for this request. 'brief': publisher curates product recommendations from the provided brief. 'wholesale': buyer requests raw inventory to apply their own audiences — brief must not be provided, and proposals are omitted. 'refine': iterate on products and proposals from a previous get_products response using the refine array of change requests. v3 clients MUST include buying_mode. Sellers receiving requests from pre-v3 clients without buying_mode SHOULD default to 'brief'." ), ] catalog: Annotated[ catalog_1.Catalog | None, Field( description='Catalog of items the buyer wants to promote. The seller matches catalog items against its inventory and returns products where matches exist. Supports all catalog types: a job catalog finds job ad products, a product catalog finds sponsored product slots. Reference a synced catalog by catalog_id, or provide inline items.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[Field1] | None, Field( description='Specific product fields to include in the response. When omitted, all fields are returned. Use for lightweight discovery calls where only a subset of product data is needed (e.g., just IDs and pricing for comparison). Required fields (product_id, name) are always included regardless of selection.', min_length=1, ), ] = None filters: product_filters.ProductFilters | None = None pagination: pagination_request.PaginationRequest | None = None preferred_delivery_types: Annotated[ list[delivery_type_1.DeliveryType] | None, Field( description='Delivery types the buyer prefers, in priority order. Unlike filters.delivery_type which excludes non-matching products, this signals preference for curation — the publisher may still include other delivery types when they match the brief well.', min_length=1, ), ] = None property_list: Annotated[ property_list_ref.PropertyListReference | None, Field( description='[AdCP 3.0] Reference to an externally managed property list. When provided, the sales agent should filter products to only those available on properties in the list.' ), ] = None refine: Annotated[ list[Refine | Refine1 | Refine2] | None, Field( description="Array of change requests for iterating on products and proposals from a previous get_products response. Each entry declares a scope (request, product, or proposal) and what the buyer is asking for. Only valid when buying_mode is 'refine'. The seller responds to each entry via refinement_applied in the response, matched by position.", min_length=1, ), ] = None required_policies: Annotated[ list[str] | None, Field( description='Registry policy IDs that the buyer requires to be enforced for products in this response. Sellers filter products to only those that comply with or already enforce the requested policies.' ), ] = None time_budget: Annotated[ duration.Duration | None, Field( description='Maximum time the buyer will commit to this request. The seller returns the best results achievable within this budget and does not start processes (human approvals, expensive external queries) that cannot complete in time. When omitted, the seller decides timing.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar brand : BrandReference | Nonevar brief : str | Nonevar buying_mode : BuyingMode | Nonevar catalog : Catalog | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[Field1] | Nonevar filters : ProductFilters | Nonevar model_configvar pagination : PaginationRequest | Nonevar preferred_delivery_types : list[DeliveryType] | Nonevar property_list : PropertyListReference | Nonevar refine : list[Refine | Refine1 | Refine2] | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
class GetProductsRefineRequest (**data: Any)-
Expand source code
class GetProductsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None brief: Annotated[ str | None, Field( description="Natural language description of campaign requirements. Required when buying_mode is 'brief'. Must not be provided when buying_mode is 'wholesale' or 'refine'." ), ] = None buying_mode: Annotated[ BuyingMode, Field( description="Declares buyer intent for this request. 'brief': publisher curates product recommendations from the provided brief. 'wholesale': buyer requests raw inventory to apply their own audiences — brief must not be provided, and proposals are omitted. 'refine': iterate on products and proposals from a previous get_products response using the refine array of change requests. v3 clients MUST include buying_mode. Sellers receiving requests from pre-v3 clients without buying_mode SHOULD default to 'brief'." ), ] catalog: Annotated[ catalog_1.Catalog | None, Field( description='Catalog of items the buyer wants to promote. The seller matches catalog items against its inventory and returns products where matches exist. Supports all catalog types: a job catalog finds job ad products, a product catalog finds sponsored product slots. Reference a synced catalog by catalog_id, or provide inline items.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[Field1] | None, Field( description='Specific product fields to include in the response. When omitted, all fields are returned. Use for lightweight discovery calls where only a subset of product data is needed (e.g., just IDs and pricing for comparison). Required fields (product_id, name) are always included regardless of selection.', min_length=1, ), ] = None filters: product_filters.ProductFilters | None = None pagination: pagination_request.PaginationRequest | None = None preferred_delivery_types: Annotated[ list[delivery_type_1.DeliveryType] | None, Field( description='Delivery types the buyer prefers, in priority order. Unlike filters.delivery_type which excludes non-matching products, this signals preference for curation — the publisher may still include other delivery types when they match the brief well.', min_length=1, ), ] = None property_list: Annotated[ property_list_ref.PropertyListReference | None, Field( description='[AdCP 3.0] Reference to an externally managed property list. When provided, the sales agent should filter products to only those available on properties in the list.' ), ] = None refine: Annotated[ list[Refine | Refine1 | Refine2] | None, Field( description="Array of change requests for iterating on products and proposals from a previous get_products response. Each entry declares a scope (request, product, or proposal) and what the buyer is asking for. Only valid when buying_mode is 'refine'. The seller responds to each entry via refinement_applied in the response, matched by position.", min_length=1, ), ] = None required_policies: Annotated[ list[str] | None, Field( description='Registry policy IDs that the buyer requires to be enforced for products in this response. Sellers filter products to only those that comply with or already enforce the requested policies.' ), ] = None time_budget: Annotated[ duration.Duration | None, Field( description='Maximum time the buyer will commit to this request. The seller returns the best results achievable within this budget and does not start processes (human approvals, expensive external queries) that cannot complete in time. When omitted, the seller decides timing.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar brand : BrandReference | Nonevar brief : str | Nonevar buying_mode : BuyingMode | Nonevar catalog : Catalog | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[Field1] | Nonevar filters : ProductFilters | Nonevar model_configvar pagination : PaginationRequest | Nonevar preferred_delivery_types : list[DeliveryType] | Nonevar property_list : PropertyListReference | Nonevar refine : list[Refine | Refine1 | Refine2] | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
class GetProductsWholesaleRequest (**data: Any)-
Expand source code
class GetProductsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None brief: Annotated[ str | None, Field( description="Natural language description of campaign requirements. Required when buying_mode is 'brief'. Must not be provided when buying_mode is 'wholesale' or 'refine'." ), ] = None buying_mode: Annotated[ BuyingMode, Field( description="Declares buyer intent for this request. 'brief': publisher curates product recommendations from the provided brief. 'wholesale': buyer requests raw inventory to apply their own audiences — brief must not be provided, and proposals are omitted. 'refine': iterate on products and proposals from a previous get_products response using the refine array of change requests. v3 clients MUST include buying_mode. Sellers receiving requests from pre-v3 clients without buying_mode SHOULD default to 'brief'." ), ] catalog: Annotated[ catalog_1.Catalog | None, Field( description='Catalog of items the buyer wants to promote. The seller matches catalog items against its inventory and returns products where matches exist. Supports all catalog types: a job catalog finds job ad products, a product catalog finds sponsored product slots. Reference a synced catalog by catalog_id, or provide inline items.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[Field1] | None, Field( description='Specific product fields to include in the response. When omitted, all fields are returned. Use for lightweight discovery calls where only a subset of product data is needed (e.g., just IDs and pricing for comparison). Required fields (product_id, name) are always included regardless of selection.', min_length=1, ), ] = None filters: product_filters.ProductFilters | None = None pagination: pagination_request.PaginationRequest | None = None preferred_delivery_types: Annotated[ list[delivery_type_1.DeliveryType] | None, Field( description='Delivery types the buyer prefers, in priority order. Unlike filters.delivery_type which excludes non-matching products, this signals preference for curation — the publisher may still include other delivery types when they match the brief well.', min_length=1, ), ] = None property_list: Annotated[ property_list_ref.PropertyListReference | None, Field( description='[AdCP 3.0] Reference to an externally managed property list. When provided, the sales agent should filter products to only those available on properties in the list.' ), ] = None refine: Annotated[ list[Refine | Refine1 | Refine2] | None, Field( description="Array of change requests for iterating on products and proposals from a previous get_products response. Each entry declares a scope (request, product, or proposal) and what the buyer is asking for. Only valid when buying_mode is 'refine'. The seller responds to each entry via refinement_applied in the response, matched by position.", min_length=1, ), ] = None required_policies: Annotated[ list[str] | None, Field( description='Registry policy IDs that the buyer requires to be enforced for products in this response. Sellers filter products to only those that comply with or already enforce the requested policies.' ), ] = None time_budget: Annotated[ duration.Duration | None, Field( description='Maximum time the buyer will commit to this request. The seller returns the best results achievable within this budget and does not start processes (human approvals, expensive external queries) that cannot complete in time. When omitted, the seller decides timing.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar brand : BrandReference | Nonevar brief : str | Nonevar buying_mode : BuyingMode | Nonevar catalog : Catalog | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[Field1] | Nonevar filters : ProductFilters | Nonevar model_configvar pagination : PaginationRequest | Nonevar preferred_delivery_types : list[DeliveryType] | Nonevar property_list : PropertyListReference | Nonevar refine : list[Refine | Refine1 | Refine2] | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
Inherited members
class GetProductsResponse (**data: Any)-
Expand source code
class GetProductsResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_applied: Annotated[ bool | None, Field( description='Whether the seller filtered results based on the provided catalog. True if the seller matched catalog items against its inventory. Absent or false if no catalog was provided or the seller does not support catalog matching.' ), ] = None context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings (e.g., product filtering issues)'), ] = None ext: ext_1.ExtensionObject | None = None incomplete: Annotated[ list[IncompleteItem] | None, Field( description="Declares what the seller could not finish within the buyer's time_budget or due to internal limits. Each entry identifies a scope that is missing or partial. Absent when the response is fully complete.", min_length=1, ), ] = None pagination: pagination_response.PaginationResponse | None = None products: Annotated[list[product_1.Product], Field(description='Array of matching products')] property_list_applied: Annotated[ bool | None, Field( description='[AdCP 3.0] Indicates whether property_list filtering was applied. True if the agent filtered products based on the provided property_list. Absent or false if property_list was not provided or not supported by this agent.' ), ] = None proposals: Annotated[ list[proposal_1.Proposal] | None, Field( description='Optional array of proposed media plans with budget allocations across products. Publishers include proposals when they can provide strategic guidance based on the brief. Proposals are actionable - buyers can refine them via follow-up get_products calls within the same session, or execute them directly via create_media_buy.' ), ] = None refinement_applied: Annotated[ list[RefinementAppliedItem] | None, Field( description="Seller's response to each change request in the refine array, matched by position. Each entry acknowledges whether the corresponding ask was applied, partially applied, or unable to be fulfilled. MUST contain the same number of entries in the same order as the request's refine array. Only present when the request used buying_mode: 'refine'." ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalog_applied : bool | Nonevar context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar incomplete : list[IncompleteItem] | Nonevar model_configvar pagination : PaginationResponse | Nonevar products : list[Product]var property_list_applied : bool | Nonevar proposals : list[Proposal] | Nonevar refinement_applied : list[RefinementAppliedItem] | Nonevar sandbox : bool | None
Inherited members
class GetPropertyListRequest (**data: Any)-
Expand source code
class GetPropertyListRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None list_id: Annotated[str, Field(description='ID of the property list to retrieve')] pagination: Annotated[ Pagination | None, Field( description='Pagination parameters. Uses higher limits than standard pagination because property lists can contain tens of thousands of identifiers.' ), ] = None resolve: Annotated[ bool | None, Field( description='Whether to apply filters and return resolved identifiers (default: true)' ), ] = TrueBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar list_id : strvar model_configvar pagination : Pagination | Nonevar resolve : bool | None
Inherited members
class GetPropertyListResponse (**data: Any)-
Expand source code
class GetPropertyListResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) cache_valid_until: Annotated[ AwareDatetime | None, Field( description='Cache expiration timestamp. Re-fetch the list after this time to get updated identifiers.' ), ] = None coverage_gaps: Annotated[ dict[str, _list[identifier.Identifier]] | None, Field( description="Properties included in the list despite missing feature data. Only present when a feature_requirement has if_not_covered='include'. Maps feature_id to list of identifiers not covered for that feature." ), ] = None ext: ext_1.ExtensionObject | None = None identifiers: Annotated[ _list[identifier.Identifier] | None, Field( description='Resolved identifiers that passed filters (if resolve=true). Cache these locally for real-time use.' ), ] = None list: Annotated[ property_list.PropertyList, Field(description='The property list metadata (always returned)'), ] pagination: pagination_response.PaginationResponse | None = None resolved_at: Annotated[ AwareDatetime | None, Field(description='When the list was resolved') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var cache_valid_until : pydantic.types.AwareDatetime | Nonevar coverage_gaps : dict[str, list[Identifier]] | Nonevar ext : ExtensionObject | Nonevar identifiers : list[Identifier] | Nonevar list : PropertyListvar model_configvar pagination : PaginationResponse | Nonevar resolved_at : pydantic.types.AwareDatetime | None
Inherited members
class GetRightsRequest (**data: Any)-
Expand source code
class GetRightsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand_id: Annotated[ str | None, Field( description="Search within a specific brand's rights. If omitted, searches across the agent's full roster." ), ] = None 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 context: context_1.ContextObject | None = 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 ext: ext_1.ExtensionObject | None = None include_excluded: Annotated[ bool | 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 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, ), ] right_type: Annotated[ right_type_1.RightType | None, Field(description='Filter by type of rights (talent, music, stock_media, etc.)'), ] = None 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, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand_id : str | Nonevar buyer_brand : BrandReference | Nonevar context : ContextObject | Nonevar countries : list[Country] | Nonevar ext : ExtensionObject | Nonevar include_excluded : bool | Nonevar model_configvar pagination : PaginationRequest | Nonevar query : strvar right_type : RightType | Nonevar uses : list[RightUse]
Inherited members
class GetRightsSuccessResponse (**data: Any)-
Expand source code
class GetRightsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None excluded: Annotated[ list[ExcludedItem] | None, Field(description='Results that matched but were filtered out, with reasons'), ] = None ext: ext_1.ExtensionObject | None = None rights: Annotated[ list[Right], Field(description='Matching rights with pricing options, ranked by relevance') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar excluded : list[ExcludedItem] | Nonevar ext : ExtensionObject | Nonevar model_configvar rights : list[Right]
Inherited members
class GetRightsErrorResponse (**data: Any)-
Expand source code
class GetRightsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[list[error.Error], Field(min_length=1)] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class GetSignalsRequest (**data: Any)-
Expand source code
class GetSignalsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for this request. When provided, the signals agent returns per-account pricing options if configured.' ), ] = None context: context_1.ContextObject | None = None countries: Annotated[ list[Country] | None, Field( description='Countries where signals will be used (ISO 3166-1 alpha-2 codes). When omitted, no geographic filter is applied.', min_length=1, ), ] = None destinations: Annotated[ list[destination.Destination] | None, Field( description='Filter signals to those activatable on specific agents/platforms. When omitted, returns all signals available on the current agent. If the authenticated caller matches one of these destinations, activation keys will be included in the response.', min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = None filters: signal_filters.SignalFilters | None = None max_results: Annotated[ int | None, Field(description='Maximum number of results to return', ge=1) ] = None pagination: pagination_request.PaginationRequest | None = None signal_ids: Annotated[ list[signal_id.SignalId] | None, Field( description="Specific signals to look up by data provider and ID. Returns exact matches from the data provider's catalog. When combined with signal_spec, these signals anchor the starting set and signal_spec guides adjustments.", min_length=1, ), ] = None signal_spec: Annotated[ str | None, Field( description='Natural language description of the desired signals. When used alone, enables semantic discovery. When combined with signal_ids, provides context for the agent but signal_ids matches are returned first.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar countries : list[Country] | Nonevar destinations : list[Destination] | Nonevar ext : ExtensionObject | Nonevar filters : SignalFilters | Nonevar max_results : int | Nonevar model_configvar pagination : PaginationRequest | Nonevar signal_ids : list[SignalId] | Nonevar signal_spec : str | None
class GetSignalsDiscoveryRequest (**data: Any)-
Expand source code
class GetSignalsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for this request. When provided, the signals agent returns per-account pricing options if configured.' ), ] = None context: context_1.ContextObject | None = None countries: Annotated[ list[Country] | None, Field( description='Countries where signals will be used (ISO 3166-1 alpha-2 codes). When omitted, no geographic filter is applied.', min_length=1, ), ] = None destinations: Annotated[ list[destination.Destination] | None, Field( description='Filter signals to those activatable on specific agents/platforms. When omitted, returns all signals available on the current agent. If the authenticated caller matches one of these destinations, activation keys will be included in the response.', min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = None filters: signal_filters.SignalFilters | None = None max_results: Annotated[ int | None, Field(description='Maximum number of results to return', ge=1) ] = None pagination: pagination_request.PaginationRequest | None = None signal_ids: Annotated[ list[signal_id.SignalId] | None, Field( description="Specific signals to look up by data provider and ID. Returns exact matches from the data provider's catalog. When combined with signal_spec, these signals anchor the starting set and signal_spec guides adjustments.", min_length=1, ), ] = None signal_spec: Annotated[ str | None, Field( description='Natural language description of the desired signals. When used alone, enables semantic discovery. When combined with signal_ids, provides context for the agent but signal_ids matches are returned first.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar countries : list[Country] | Nonevar destinations : list[Destination] | Nonevar ext : ExtensionObject | Nonevar filters : SignalFilters | Nonevar max_results : int | Nonevar model_configvar pagination : PaginationRequest | Nonevar signal_ids : list[SignalId] | Nonevar signal_spec : str | None
class GetSignalsLookupRequest (**data: Any)-
Expand source code
class GetSignalsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference | None, Field( description='Account for this request. When provided, the signals agent returns per-account pricing options if configured.' ), ] = None context: context_1.ContextObject | None = None countries: Annotated[ list[Country] | None, Field( description='Countries where signals will be used (ISO 3166-1 alpha-2 codes). When omitted, no geographic filter is applied.', min_length=1, ), ] = None destinations: Annotated[ list[destination.Destination] | None, Field( description='Filter signals to those activatable on specific agents/platforms. When omitted, returns all signals available on the current agent. If the authenticated caller matches one of these destinations, activation keys will be included in the response.', min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = None filters: signal_filters.SignalFilters | None = None max_results: Annotated[ int | None, Field(description='Maximum number of results to return', ge=1) ] = None pagination: pagination_request.PaginationRequest | None = None signal_ids: Annotated[ list[signal_id.SignalId] | None, Field( description="Specific signals to look up by data provider and ID. Returns exact matches from the data provider's catalog. When combined with signal_spec, these signals anchor the starting set and signal_spec guides adjustments.", min_length=1, ), ] = None signal_spec: Annotated[ str | None, Field( description='Natural language description of the desired signals. When used alone, enables semantic discovery. When combined with signal_ids, provides context for the agent but signal_ids matches are returned first.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReference | Nonevar context : ContextObject | Nonevar countries : list[Country] | Nonevar destinations : list[Destination] | Nonevar ext : ExtensionObject | Nonevar filters : SignalFilters | Nonevar max_results : int | Nonevar model_configvar pagination : PaginationRequest | Nonevar signal_ids : list[SignalId] | Nonevar signal_spec : str | None
Inherited members
class GetSignalsResponse (**data: Any)-
Expand source code
class GetSignalsResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error] | None, Field( description='Task-specific errors and warnings (e.g., signal discovery or pricing issues)' ), ] = None ext: ext_1.ExtensionObject | None = None pagination: pagination_response.PaginationResponse | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None signals: Annotated[list[Signal], Field(description='Array of matching signals')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar pagination : PaginationResponse | Nonevar sandbox : bool | Nonevar signals : list[Signal]
Inherited members
class Gtin (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class Gtin(RootModel[str]): root: Annotated[str, Field(pattern='^[0-9]{8,14}$')]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : str
class HtmlAsset (**data: Any)-
Expand source code
class HtmlAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accessibility: Annotated[ Accessibility | None, Field(description='Self-declared accessibility properties for this opaque creative'), ] = None content: Annotated[str, Field(description='HTML content')] provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None version: Annotated[str | None, Field(description="HTML version (e.g., 'HTML5')")] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accessibility : Accessibility | Nonevar content : strvar model_configvar provenance : Provenance | Nonevar version : str | None
Inherited members
class HttpMethod (*args, **kwds)-
Expand source code
class HttpMethod(Enum): GET = 'GET' POST = 'POST'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var GETvar POST
class Method (*args, **kwds)-
Expand source code
class HttpMethod(Enum): GET = 'GET' POST = 'POST'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var GETvar POST
class Identifier (**data: Any)-
Expand source code
class Identifier(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) type: Annotated[ distribution_identifier_type.DistributionIdentifierType, Field(description='Type of distribution identifier'), ] value: Annotated[str, Field(description='The identifier value')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar type : DistributionIdentifierTypevar value : str
Inherited members
class IdentityMatchRequest (**data: Any)-
Expand source code
class IdentityMatchRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) field_schema: Annotated[ AnyUrl | None, Field( alias='$schema', description='Optional schema URI for validation. Ignored at runtime.' ), ] = None consent: Annotated[ Consent | None, Field( description='Privacy consent signals. Buyers in regulated jurisdictions MUST NOT process the user token without consent information.' ), ] = None package_ids: Annotated[ list[str], Field( description='ALL active package identifiers for this buyer at this publisher. MUST include every active package, not just those on the current page, to prevent correlation with Context Match requests.', min_length=1, ), ] protocol_version: Annotated[ str | None, Field( description='TMP protocol version. Allows receivers to handle semantic differences across versions.' ), ] = '1.0' request_id: Annotated[ str, Field( description='Unique request identifier. MUST NOT correlate with any context match request_id.' ), ] type: Annotated[ Literal['identity_match_request'], Field(description='Message type discriminator for deserialization.'), ] uid_type: Annotated[ uid_type_1.UidType, Field( description='Type of the user identifier. Tells the buyer which identity graph to resolve against, avoiding trial-and-error matching.' ), ] user_token: Annotated[ str, Field( description='Opaque token from an identity provider (ID5, LiveRamp, UID2) or publisher-generated' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var consent : Consent | Nonevar field_schema : pydantic.networks.AnyUrl | Nonevar model_configvar package_ids : list[str]var protocol_version : str | Nonevar request_id : strvar type : Literal['identity_match_request']var uid_type : UidTypevar user_token : str
Inherited members
class IdentityMatchResponse (**data: Any)-
Expand source code
class IdentityMatchResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) eligible_package_ids: Annotated[ list[str], Field( description='Package IDs the user is eligible for. Packages not listed are ineligible.' ), ] request_id: Annotated[ str, Field(description='Echoed request identifier from the identity match request') ] ttl_sec: Annotated[ int, Field( description='How long the router should cache this response, in seconds. The router returns cached eligibility without re-querying the buyer during this window. A value of 0 means do not cache.', ge=0, le=86400, ), ] type: Annotated[ Literal['identity_match_response'], Field(description='Message type discriminator for deserialization.'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var eligible_package_ids : list[str]var model_configvar request_id : strvar ttl_sec : intvar type : Literal['identity_match_response']
Inherited members
class ImageAsset (**data: Any)-
Expand source code
class ImageAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) alt_text: Annotated[str | None, Field(description='Alternative text for accessibility')] = None format: Annotated[ str | None, Field(description='Image file format (jpg, png, gif, webp, etc.)') ] = None height: Annotated[int, Field(description='Height in pixels', ge=1)] provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None url: Annotated[AnyUrl, Field(description='URL to the image asset')] width: Annotated[int, Field(description='Width in pixels', ge=1)]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var alt_text : str | Nonevar format : str | Nonevar height : intvar model_configvar provenance : Provenance | Nonevar url : pydantic.networks.AnyUrlvar width : int
Inherited members
class Input (**data: Any)-
Expand source code
class Input(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context_description: Annotated[ str | None, Field(description='Natural language description of the context for AI-generated content'), ] = None macros: Annotated[ dict[str, str] | None, Field(description='Macro values to apply for this preview') ] = None name: Annotated[str, Field(description='Human-readable name for this preview variant')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context_description : str | Nonevar macros : dict[str, str] | Nonevar model_configvar name : str
Inherited members
class JavascriptAsset (**data: Any)-
Expand source code
class JavascriptAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accessibility: Annotated[ Accessibility | None, Field(description='Self-declared accessibility properties for this opaque creative'), ] = None content: Annotated[str, Field(description='JavaScript content')] module_type: Annotated[ javascript_module_type.JavascriptModuleType | None, Field(description='JavaScript module type'), ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accessibility : Accessibility | Nonevar content : strvar model_configvar module_type : JavascriptModuleType | Nonevar provenance : Provenance | None
Inherited members
class JavascriptModuleType (*args, **kwds)-
Expand source code
class JavascriptModuleType(Enum): esm = 'esm' commonjs = 'commonjs' script = 'script'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var commonjsvar esmvar script
class ModuleType (*args, **kwds)-
Expand source code
class JavascriptModuleType(Enum): esm = 'esm' commonjs = 'commonjs' script = 'script'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var commonjsvar esmvar script
class LandingPageRequirement (*args, **kwds)-
Expand source code
class LandingPageRequirement(Enum): any = 'any' retailer_site_only = 'retailer_site_only' must_include_retailer = 'must_include_retailer'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var anyvar must_include_retailervar retailer_site_only
class LandingPage (*args, **kwds)-
Expand source code
class LandingPageRequirement(Enum): any = 'any' retailer_site_only = 'retailer_site_only' must_include_retailer = 'must_include_retailer'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var anyvar must_include_retailervar retailer_site_only
class ListAccountsRequest (**data: Any)-
Expand source code
class ListAccountsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None pagination: pagination_request.PaginationRequest | None = None sandbox: Annotated[ bool | None, Field( description='Filter by sandbox status. true returns only sandbox accounts, false returns only production accounts. Omit to return all accounts. Primarily used with explicit accounts (require_operator_auth: true) where sandbox accounts are pre-existing test accounts on the platform.' ), ] = None status: Annotated[ Status | None, Field(description='Filter accounts by status. Omit to return accounts in all statuses.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar pagination : PaginationRequest | Nonevar sandbox : bool | Nonevar status : Status | None
Inherited members
class ListAccountsResponse (**data: Any)-
Expand source code
class ListAccountsResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accounts: Annotated[ list[account.Account], Field(description='Array of accounts accessible to the authenticated agent'), ] context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None ext: ext_1.ExtensionObject | None = None pagination: pagination_response.PaginationResponse | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accounts : list[Account]var context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar pagination : PaginationResponse | None
Inherited members
class ListContentStandardsRequest (**data: Any)-
Expand source code
class ListContentStandardsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) channels: Annotated[ list[channels_1.MediaChannel] | None, Field(description='Filter by channel', min_length=1) ] = None context: context_1.ContextObject | None = None countries: Annotated[ list[str] | None, Field(description='Filter by ISO 3166-1 alpha-2 country codes', min_length=1), ] = None ext: ext_1.ExtensionObject | None = None languages: Annotated[ list[str] | None, Field(description='Filter by BCP 47 language tags', min_length=1) ] = None pagination: pagination_request.PaginationRequest | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var channels : list[MediaChannel] | Nonevar context : ContextObject | Nonevar countries : list[str] | Nonevar ext : ExtensionObject | Nonevar languages : list[str] | Nonevar model_configvar pagination : PaginationRequest | None
Inherited members
class ListContentStandardsSuccessResponse (**data: Any)-
Expand source code
class ListContentStandardsResponse1(AdCPBaseModel): context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None pagination: pagination_response.PaginationResponse | None = None standards: Annotated[ list[content_standards.ContentStandards], Field(description='Array of content standards configurations matching the filter criteria'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar pagination : PaginationResponse | Nonevar standards : list[ContentStandards]
Inherited members
class ListContentStandardsErrorResponse (**data: Any)-
Expand source code
class ListContentStandardsResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class ListCreativeFormatsRequest (**data: Any)-
Expand source code
class ListCreativeFormatsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) asset_types: Annotated[ list[asset_content_type.AssetContentType] | None, Field( description="Filter to formats that include these asset types. For third-party tags, search for 'html' or 'javascript'. E.g., ['image', 'text'] returns formats with images and text, ['javascript'] returns formats accepting JavaScript tags.", min_length=1, ), ] = None context: context_1.ContextObject | None = None disclosure_persistence: Annotated[ list[disclosure_persistence_1.DisclosurePersistence] | None, Field( description='Filter to formats where each requested persistence mode is supported by at least one position in disclosure_capabilities. Different positions may satisfy different modes. Use to find formats compatible with jurisdiction-specific persistence requirements (e.g., continuous for EU AI Act).', min_length=1, ), ] = None disclosure_positions: Annotated[ list[disclosure_position.DisclosurePosition] | None, Field( description="Filter to formats that support all of these disclosure positions. When a format has disclosure_capabilities, match against those positions. Otherwise fall back to supported_disclosure_positions. Use to find formats compatible with a brief's compliance requirements.", min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Return only these specific format IDs (e.g., from get_products response)', min_length=1, ), ] = None input_format_ids: Annotated[ list[format_id.FormatId] | None, Field( description="Filter to formats whose input_format_ids includes any of these format IDs. Returns formats that accept these creatives as input — inspect each result's output_format_ids to see what they can produce.", min_length=1, ), ] = None is_responsive: Annotated[ bool | None, Field( description='Filter for responsive formats that adapt to container size. When true, returns formats without fixed dimensions.' ), ] = None max_height: Annotated[ int | None, Field( description='Maximum height in pixels (inclusive). Returns formats where ANY render has height <= this value. For multi-render formats, matches if at least one render fits.' ), ] = None max_width: Annotated[ int | None, Field( description='Maximum width in pixels (inclusive). Returns formats where ANY render has width <= this value. For multi-render formats, matches if at least one render fits.' ), ] = None min_height: Annotated[ int | None, Field( description='Minimum height in pixels (inclusive). Returns formats where ANY render has height >= this value.' ), ] = None min_width: Annotated[ int | None, Field( description='Minimum width in pixels (inclusive). Returns formats where ANY render has width >= this value.' ), ] = None name_search: Annotated[ str | None, Field(description='Search for formats by name (case-insensitive partial match)') ] = None output_format_ids: Annotated[ list[format_id.FormatId] | None, Field( description="Filter to formats whose output_format_ids includes any of these format IDs. Returns formats that can produce these outputs — inspect each result's input_format_ids to see what inputs they accept.", min_length=1, ), ] = None pagination: pagination_request.PaginationRequest | None = None wcag_level: Annotated[ wcag_level_1.WcagLevel | None, Field( description='Filter to formats that meet at least this WCAG conformance level (A < AA < AAA)' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var asset_types : list[AssetContentType] | Nonevar context : ContextObject | Nonevar disclosure_persistence : list[DisclosurePersistence] | Nonevar disclosure_positions : list[DisclosurePosition] | Nonevar ext : ExtensionObject | Nonevar format_ids : list[FormatId] | Nonevar input_format_ids : list[FormatId] | Nonevar is_responsive : bool | Nonevar max_height : int | Nonevar max_width : int | Nonevar min_height : int | Nonevar min_width : int | Nonevar model_configvar name_search : str | Nonevar output_format_ids : list[FormatId] | Nonevar pagination : PaginationRequest | Nonevar wcag_level : WcagLevel | None
Inherited members
class ListCreativeFormatsResponse (**data: Any)-
Expand source code
class ListCreativeFormatsResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_agents: Annotated[ list[CreativeAgent] | None, Field( description='Optional: Creative agents that provide additional formats. Buyers can recursively query these agents to discover more formats. No authentication required for list_creative_formats.' ), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings (e.g., format availability issues)'), ] = None ext: ext_1.ExtensionObject | None = None formats: Annotated[ list[format.Format], Field( description="Full format definitions for all formats this agent supports. Each format's authoritative source is indicated by its agent_url field." ), ] pagination: pagination_response.PaginationResponse | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_agents : list[CreativeAgent] | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar formats : list[Format]var model_configvar pagination : PaginationResponse | Nonevar sandbox : bool | None
Inherited members
class ListCreativesRequest (**data: Any)-
Expand source code
class ListCreativesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None fields: Annotated[ list[Field1] | None, Field( description="Specific fields to include in response (omit for all fields). The 'concept' value returns both concept_id and concept_name.", min_length=1, ), ] = None filters: creative_filters.CreativeFilters | None = None include_assignments: Annotated[ bool | None, Field(description='Include package assignment information in response') ] = True include_items: Annotated[ bool | None, Field(description='Include items for multi-asset formats like carousels and native ads'), ] = False include_snapshot: Annotated[ bool | None, Field( description='Include a lightweight delivery snapshot per creative (lifetime impressions and last-served date). For detailed performance analytics, use get_creative_delivery.' ), ] = False include_variables: Annotated[ bool | None, Field( description='Include dynamic content variable definitions (DCO slots) for each creative' ), ] = False pagination: pagination_request.PaginationRequest | None = None sort: Annotated[Sort | None, Field(description='Sorting parameters')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar fields : list[Field1] | Nonevar filters : CreativeFilters | Nonevar include_assignments : bool | Nonevar include_items : bool | Nonevar include_snapshot : bool | Nonevar include_variables : bool | Nonevar model_configvar pagination : PaginationRequest | Nonevar sort : Sort | None
Inherited members
class ListCreativesResponse (**data: Any)-
Expand source code
class ListCreativesResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creatives: Annotated[ list[Creative], Field(description='Array of creative assets matching the query') ] errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors (e.g., invalid filters, account not found)'), ] = None ext: ext_1.ExtensionObject | None = None format_summary: Annotated[ dict[Annotated[str, StringConstraints(pattern=r'^[a-zA-Z0-9_-]+$')], int] | None, Field( description="Breakdown of creatives by format. Keys are agent-defined format identifiers, optionally including dimensions (e.g., 'display_static_300x250', 'video_30s_vast'). Key construction is platform-specific — there is no required format." ), ] = None pagination: pagination_response.PaginationResponse query_summary: Annotated[ QuerySummary, Field(description='Summary of the query that was executed') ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None status_summary: Annotated[ StatusSummary | None, Field(description='Breakdown of creatives by status') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creatives : list[Creative]var errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar format_summary : dict[str, int] | Nonevar model_configvar pagination : PaginationResponsevar query_summary : QuerySummaryvar sandbox : bool | Nonevar status_summary : StatusSummary | None
Inherited members
class ListPropertyListsRequest (**data: Any)-
Expand source code
class ListPropertyListsRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None name_contains: Annotated[ str | None, Field(description='Filter to lists whose name contains this string') ] = None pagination: pagination_request.PaginationRequest | None = None principal: Annotated[ str | None, Field(description='Filter to lists owned by this principal') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar name_contains : str | Nonevar pagination : PaginationRequest | Nonevar principal : str | None
Inherited members
class ListPropertyListsResponse (**data: Any)-
Expand source code
class ListPropertyListsResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) ext: ext_1.ExtensionObject | None = None lists: Annotated[ list[property_list.PropertyList], Field(description='Array of property lists (metadata only, not resolved properties)'), ] pagination: pagination_response.PaginationResponse | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var ext : ExtensionObject | Nonevar lists : list[PropertyList]var model_configvar pagination : PaginationResponse | None
Inherited members
class LogEventRequest (**data: Any)-
Expand source code
class LogEventRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None event_source_id: Annotated[ str, Field(description='Event source configured on the account via sync_event_sources') ] events: Annotated[ list[event.Event], Field(description='Events to log', max_length=10000, min_length=1) ] ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate event logging on 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, ), ] = None test_event_code: Annotated[ str | None, Field( description="Test event code for validation without affecting production data. Events with this code appear in the platform's test events UI." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar event_source_id : strvar events : list[Event]var ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar test_event_code : str | None
Inherited members
class LogEventSuccessResponse (**data: Any)-
Expand source code
class LogEventResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None events_processed: Annotated[ int, Field(description='Number of events successfully queued for processing', ge=0) ] events_received: Annotated[int, Field(description='Number of events received', ge=0)] ext: ext_1.ExtensionObject | None = None match_quality: Annotated[ float | None, Field( description='Overall match quality score for the batch (0.0 = no matches, 1.0 = all matched)', ge=0.0, le=1.0, ), ] = None partial_failures: Annotated[ list[PartialFailure] | None, Field(description='Events that failed validation') ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None warnings: Annotated[ list[str] | None, Field( description='Non-fatal issues (low match quality, missing recommended fields, deprecation notices)' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar events_processed : intvar events_received : intvar ext : ExtensionObject | Nonevar match_quality : float | Nonevar model_configvar partial_failures : list[PartialFailure] | Nonevar sandbox : bool | Nonevar warnings : list[str] | None
Inherited members
class LogEventErrorResponse (**data: Any)-
Expand source code
class LogEventResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[list[error.Error], Field(description='Operation-level errors', min_length=1)] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class Logo (**data: Any)-
Expand source code
class Logo(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) background: Annotated[Background3 | None, Field(description='Background compatibility')] = None height: Annotated[int | None, Field(description='Height in pixels')] = None orientation: Annotated[ Orientation | None, Field(description='Logo aspect ratio orientation') ] = None tags: Annotated[list[str] | None, Field(description='Additional semantic tags')] = None url: Annotated[AnyUrl, Field(description='URL to the logo asset')] usage: Annotated[str | None, Field(description='When to use this logo variant')] = None variant: Annotated[Variant | None, Field(description='Logo variant type')] = None width: Annotated[int | None, Field(description='Width in pixels')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var background : Background3 | Nonevar height : int | Nonevar model_configvar orientation : Orientation | Nonevar url : pydantic.networks.AnyUrlvar usage : str | Nonevar variant : Variant | Nonevar width : int | None
Inherited members
class MarkdownFlavor (*args, **kwds)-
Expand source code
class MarkdownFlavor(Enum): commonmark = 'commonmark' gfm = 'gfm'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var commonmarkvar gfm
class McpWebhookPayload (**data: Any)-
Expand source code
class McpWebhookPayload(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context_id: Annotated[ str | None, Field( description='Session/conversation identifier. Use this to continue the conversation if input-required status needs clarification or additional parameters.' ), ] = None domain: Annotated[ adcp_domain.AdcpDomain | None, Field( description='AdCP domain this task belongs to. Helps classify the operation type at a high level.' ), ] = None message: Annotated[ str | None, Field( description='Human-readable summary of the current task state. Provides context about what happened and what action may be needed.' ), ] = None operation_id: Annotated[ str | None, Field( description='Client-generated identifier that was embedded in the webhook URL by the buyer. Publishers echo this back in webhook payloads so clients can correlate notifications without parsing URL paths. Typically generated as a unique ID per task invocation.' ), ] = None result: Annotated[ async_response_data.AdcpAsyncResponseData | None, Field( description='Task-specific payload matching the status. For completed/failed, contains the full task response. For working/input-required/submitted, contains status-specific data. This is the data layer that AdCP specs - same structure used in A2A status.message.parts[].data.' ), ] = None status: Annotated[ task_status.TaskStatus, Field( description='Current task status. Webhooks are triggered for status changes after initial submission.' ), ] task_id: Annotated[ str, Field( description='Unique identifier for this task. Use this to correlate webhook notifications with the original task submission.' ), ] task_type: Annotated[ task_type_1.TaskType, Field( description='Type of AdCP operation that triggered this webhook. Enables webhook handlers to route to appropriate processing logic.' ), ] timestamp: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when this webhook was generated.') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context_id : str | Nonevar domain : AdcpDomain | Nonevar message : str | Nonevar model_configvar operation_id : str | Nonevar result : AdcpAsyncResponseData | Nonevar status : TaskStatusvar task_id : strvar task_type : TaskTypevar timestamp : pydantic.types.AwareDatetime
Inherited members
class MeasurementPeriod (**data: Any)-
Expand source code
class MeasurementPeriod(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) end: Annotated[ AwareDatetime, Field(description='ISO 8601 end timestamp for measurement period') ] start: Annotated[ AwareDatetime, Field(description='ISO 8601 start timestamp for measurement period') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var end : pydantic.types.AwareDatetimevar model_configvar start : pydantic.types.AwareDatetime
Inherited members
class MediaBuy (**data: Any)-
Expand source code
class MediaBuy(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_1.Account | None, Field(description='Account billed for this media buy') ] = None cancellation: Annotated[ Cancellation | None, Field(description="Cancellation metadata. Present only when status is 'canceled'."), ] = None confirmed_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when the seller confirmed this media buy. A successful create_media_buy response constitutes order confirmation.' ), ] = None created_at: Annotated[AwareDatetime | None, Field(description='Creation timestamp')] = None creative_deadline: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp for creative upload deadline') ] = None ext: ext_1.ExtensionObject | None = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description="Per-buy override for who receives the invoice. When provided, the seller invoices this entity instead of the account's default billing_entity. The seller MUST validate the invoice recipient is authorized for this account. When governance_agents are configured, the seller MUST include invoice_recipient in the check_governance request." ), ] = None media_buy_id: Annotated[str, Field(description="Seller's unique identifier for the media buy")] packages: Annotated[ list[package.Package], Field(description='Array of packages within this media buy') ] rejection_reason: Annotated[ str | None, Field( description="Reason provided by the seller when status is 'rejected'. Present only when status is 'rejected'." ), ] = None revision: Annotated[ int | None, Field( description='Monotonically increasing revision number. Incremented on every state change or update. Callers MAY include this in update_media_buy requests for optimistic concurrency — sellers MUST reject with CONFLICT if the provided revision does not match the current value.', ge=1, ), ] = None status: media_buy_status.MediaBuyStatus total_budget: Annotated[float, Field(description='Total budget amount', ge=0.0)] updated_at: Annotated[AwareDatetime | None, Field(description='Last update timestamp')] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : Account | Nonevar cancellation : Cancellation | Nonevar confirmed_at : pydantic.types.AwareDatetime | Nonevar created_at : pydantic.types.AwareDatetime | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar packages : list[Package]var rejection_reason : str | Nonevar revision : int | Nonevar status : MediaBuyStatusvar total_budget : floatvar updated_at : pydantic.types.AwareDatetime | None
Inherited members
class MediaBuyDelivery (**data: Any)-
Expand source code
class MediaBuyDelivery(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) by_package: Annotated[list[ByPackageItem], Field(description='Metrics broken down by package')] daily_breakdown: Annotated[ list[DailyBreakdownItem1] | None, Field(description='Day-by-day delivery') ] = None expected_availability: Annotated[ AwareDatetime | None, Field( description='When delayed data is expected to be available (only present when status is reporting_delayed)' ), ] = None is_adjusted: Annotated[ bool | None, Field( description='Indicates this delivery contains updated data for a previously reported period. Buyer should replace previous period data with these totals.' ), ] = None media_buy_id: Annotated[str, Field(description="Seller's media buy identifier")] pricing_model: Annotated[ pricing_model_1.PricingModel | None, Field(description='Pricing model used for this media buy'), ] = None status: Annotated[ Status, Field( description='Current media buy status. Lifecycle states use the same taxonomy as media-buy-status (`pending_activation`, `active`, `paused`, `completed`, `rejected`, `canceled`). In webhook context, reporting_delayed indicates data temporarily unavailable. `pending` is accepted as a legacy alias for pending_activation.' ), ] totals: TotalsBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var by_package : list[ByPackageItem]var daily_breakdown : list[DailyBreakdownItem1] | Nonevar expected_availability : pydantic.types.AwareDatetime | Nonevar is_adjusted : bool | Nonevar media_buy_id : strvar model_configvar pricing_model : PricingModel | Nonevar status : Statusvar totals : Totals
Inherited members
class MediaBuyStatus (*args, **kwds)-
Expand source code
class MediaBuyStatus(Enum): pending_activation = 'pending_activation' active = 'active' paused = 'paused' completed = 'completed' rejected = 'rejected' canceled = 'canceled'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var activevar canceledvar completedvar pausedvar pending_activationvar rejected
class MediaChannel (*args, **kwds)-
Expand source code
class MediaChannel(Enum): display = 'display' olv = 'olv' social = 'social' search = 'search' ctv = 'ctv' linear_tv = 'linear_tv' radio = 'radio' streaming_audio = 'streaming_audio' podcast = 'podcast' dooh = 'dooh' ooh = 'ooh' print = 'print' cinema = 'cinema' email = 'email' gaming = 'gaming' retail_media = 'retail_media' influencer = 'influencer' affiliate = 'affiliate' product_placement = 'product_placement' sponsored_intelligence = 'sponsored_intelligence'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var affiliatevar cinemavar ctvvar displayvar doohvar emailvar gamingvar influencervar linear_tvvar olvvar oohvar podcastvar printvar product_placementvar radiovar retail_mediavar searchvar sponsored_intelligencevar streaming_audio
class MediaSubAsset (*args: object, **kwargs: object)-
Expand source code
class MediaSubAsset: """Removed from ADCP schema. Previously SubAsset with asset_kind='media'.""" def __init__(self, *args: object, **kwargs: object) -> None: raise TypeError( "MediaSubAsset was removed from the ADCP schema. " "There is no direct replacement." )Removed from ADCP schema. Previously SubAsset with asset_kind='media'.
class Member (**data: Any)-
Expand source code
class Member(BaseModel): """An organization registered in the AAO member directory.""" model_config = ConfigDict(extra="allow") id: str slug: str display_name: str description: str | None = None tagline: str | None = None logo_url: str | None = None logo_light_url: str | None = None logo_dark_url: str | None = None contact_email: str | None = None contact_website: str | None = None offerings: list[str] = Field(default_factory=list) markets: list[str] = Field(default_factory=list) agents: list[dict[str, Any]] = Field(default_factory=list) brands: list[dict[str, Any]] = Field(default_factory=list) is_public: bool = True is_founding_member: bool = False featured: bool = False si_enabled: bool = FalseAn organization registered in the AAO member directory.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var agents : list[dict[str, typing.Any]]var brands : list[dict[str, typing.Any]]var contact_email : str | Nonevar contact_website : str | Nonevar description : str | Nonevar display_name : strvar featured : boolvar id : strvar is_founding_member : boolvar is_public : boolvar logo_dark_url : str | Nonevar logo_light_url : str | Nonevar logo_url : str | Nonevar markets : list[str]var model_configvar offerings : list[str]var si_enabled : boolvar slug : strvar tagline : str | None
class Metadata (**data: Any)-
Expand source code
class Metadata(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) author: Annotated[str | None, Field(description='Artifact author name')] = None canonical: Annotated[AnyUrl | None, Field(description='Canonical URL')] = None json_ld: Annotated[ list[dict[str, Any]] | None, Field(description='JSON-LD structured data (schema.org)') ] = None keywords: Annotated[str | None, Field(description='Artifact keywords')] = None open_graph: Annotated[ dict[str, Any] | None, Field(description='Open Graph protocol metadata') ] = None twitter_card: Annotated[dict[str, Any] | None, Field(description='Twitter Card metadata')] = ( None )Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var canonical : pydantic.networks.AnyUrl | Nonevar json_ld : list[dict[str, typing.Any]] | Nonevar keywords : str | Nonevar model_configvar open_graph : dict[str, typing.Any] | Nonevar twitter_card : dict[str, typing.Any] | None
Inherited members
class MetricType (*args, **kwds)-
Expand source code
class MetricType(Enum): overall_performance = 'overall_performance' conversion_rate = 'conversion_rate' brand_lift = 'brand_lift' click_through_rate = 'click_through_rate' completion_rate = 'completion_rate' viewability = 'viewability' brand_safety = 'brand_safety' cost_efficiency = 'cost_efficiency'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var brand_liftvar brand_safetyvar click_through_ratevar completion_ratevar conversion_ratevar cost_efficiencyvar overall_performancevar viewability
class NotificationType (*args, **kwds)-
Expand source code
class NotificationType(Enum): scheduled = 'scheduled' final = 'final' delayed = 'delayed' adjusted = 'adjusted'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var adjustedvar delayedvar finalvar scheduled
class TmpOffer (**data: Any)-
Expand source code
class Offer(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand for this offer. Required when the product allows dynamic brands (brand selected at match time rather than fixed on the package). For single-brand packages, the brand is already known from the media buy.' ), ] = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest | None, Field( description='Full creative details, inline. When present, the publisher has everything needed to render. Inline for small creatives (markdown, product card). For large creatives (VAST, video), the manifest references external assets via URLs.' ), ] = None macros: Annotated[ dict[str, str] | None, Field( description='Key-value pairs the buyer passes for dynamic creative rendering or attribution tracking. In the GAM case, these flow as macro values. Not tied to user identity — attribution reconciliation happens via delivery reporting or clean room.' ), ] = None package_id: Annotated[str, Field(description='Package identifier from the media buy.')] price: Annotated[ offer_price.OfferPrice | None, Field( description='Price for this offer. Only present when the product supports variable pricing. For fixed-price packages, price is already set on the media buy.' ), ] = None summary: Annotated[ str | None, Field( description="Buyer-generated description of the offer, for the publisher to judge relevance. E.g., '50% off Goldenfield mayo — recipe integration'. The publisher (or their AI assistant) uses this to decide whether the offer fits the context." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brand : BrandReference | Nonevar creative_manifest : CreativeManifest | Nonevar macros : dict[str, str] | Nonevar model_configvar package_id : strvar price : OfferPrice | Nonevar summary : str | None
Inherited members
class OfferPrice (**data: Any)-
Expand source code
class OfferPrice(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) amount: Annotated[float, Field(description='Price amount in the specified currency', ge=0.0)] currency: Annotated[ str | None, Field(description='ISO 4217 currency code', pattern='^[A-Z]{3}$') ] = 'USD' model: Annotated[Model, Field(description='Pricing model for this offer')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var amount : floatvar currency : str | Nonevar model : Modelvar model_config
Inherited members
class Offering (**data: Any)-
Expand source code
class Offering(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assets: Annotated[ list[offering_asset_group.OfferingAssetGroup] | None, Field( description='Structured asset groups for this offering. Each group carries a typed pool of creative assets (headlines, images, videos, etc.) identified by a group ID that matches format-level vocabulary.' ), ] = None categories: Annotated[ list[str] | None, Field( description="Categories this offering belongs to (e.g., 'measurement', 'identity', 'programmatic')" ), ] = None checkout_url: Annotated[ AnyUrl | None, Field( description="URL for checkout/purchase flow when the brand doesn't support agentic checkout." ), ] = None description: Annotated[str | None, Field(description="Description of what's being offered")] = ( None ) ext: ext_1.ExtensionObject | None = None geo_targets: Annotated[ GeoTargets | None, Field( description="Geographic scope of this offering. Declares where the offering is relevant — for location-specific offerings such as job vacancies, in-store promotions, or local events. Platforms use this to target geographically appropriate audiences and to filter out offerings irrelevant to a user's location. Uses the same geographic structures as targeting_overlay in create_media_buy." ), ] = None keywords: Annotated[ list[str] | None, Field( description='Keywords for matching this offering to user intent. Hosts use these for retrieval/relevance scoring.' ), ] = None landing_url: Annotated[ AnyUrl | None, Field( description="Landing page URL for this offering. For catalog-driven creatives, this is the per-item click-through destination that platforms map to the ad's link-out URL. Every offering in a catalog should have a landing_url unless the format provides its own destination logic." ), ] = None name: Annotated[ str, Field( description="Human-readable offering name (e.g., 'Winter Sale', 'Free Trial', 'Enterprise Platform')" ), ] offering_id: Annotated[ str, Field( description='Unique identifier for this offering. Used by hosts to reference specific offerings in si_get_offering calls.' ), ] tagline: Annotated[ str | None, Field(description='Short promotional tagline for the offering') ] = None valid_from: Annotated[ AwareDatetime | None, Field( description='When the offering becomes available. If not specified, offering is immediately available.' ), ] = None valid_to: Annotated[ AwareDatetime | None, Field( description='When the offering expires. If not specified, offering has no expiration.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var assets : list[OfferingAssetGroup] | Nonevar categories : list[str] | Nonevar checkout_url : pydantic.networks.AnyUrl | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar geo_targets : GeoTargets | Nonevar keywords : list[str] | Nonevar landing_url : pydantic.networks.AnyUrl | Nonevar model_configvar name : strvar offering_id : strvar tagline : str | Nonevar valid_from : pydantic.types.AwareDatetime | Nonevar valid_to : pydantic.types.AwareDatetime | None
Inherited members
class OfferingAssetConstraint (**data: Any)-
Expand source code
class OfferingAssetConstraint(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) asset_group_id: Annotated[ str, Field( description="The asset group this constraint applies to. Values are format-defined vocabulary — each format chooses its own group IDs (e.g., 'headlines', 'images', 'videos'). Buyers discover them via list_creative_formats." ), ] asset_requirements: Annotated[ asset_requirements_1.AssetRequirements | None, Field( description='Technical requirements for each item in this group (e.g., max_length for text, min_width/aspect_ratio for images). Applies uniformly to all items in the group.' ), ] = None asset_type: Annotated[ asset_content_type.AssetContentType, Field(description='The expected content type for this group.'), ] ext: ext_1.ExtensionObject | None = None max_count: Annotated[ int | None, Field(description='Maximum number of items allowed in this group.', ge=1) ] = None min_count: Annotated[ int | None, Field(description='Minimum number of items required in this group.', ge=1) ] = None required: Annotated[ bool | None, Field( description='Whether this asset group must be present in each offering. Defaults to true.' ), ] = TrueBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var asset_group_id : strvar asset_requirements : AssetRequirements | Nonevar asset_type : AssetContentTypevar ext : ExtensionObject | Nonevar max_count : int | Nonevar min_count : int | Nonevar model_configvar required : bool | None
Inherited members
class OfferingAssetGroup (**data: Any)-
Expand source code
class OfferingAssetGroup(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) asset_group_id: Annotated[ str, Field( description="Identifies the creative role this group fills. Values are defined by each format's offering_asset_constraints — not protocol constants. Discover them via list_creative_formats (e.g., a format might declare 'headlines', 'images', or 'videos')." ), ] asset_type: Annotated[ asset_content_type.AssetContentType, Field(description='The content type of all items in this group.'), ] ext: ext_1.ExtensionObject | None = None items: Annotated[ list[ text_asset.TextAsset | image_asset.ImageAsset | video_asset.VideoAsset | audio_asset.AudioAsset | url_asset.UrlAsset | html_asset.HtmlAsset | markdown_asset.MarkdownAsset | vast_asset.VastAsset | daast_asset.DaastAsset | css_asset.CssAsset | javascript_asset.JavascriptAsset | webhook_asset.WebhookAsset ], Field( description='The assets in this group. Each item should match the structure for the declared asset_type. Note: JSON Schema validation accepts any valid asset structure here; enforcement that items match asset_type is the responsibility of the consuming agent.', min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var asset_group_id : strvar asset_type : AssetContentTypevar ext : ExtensionObject | Nonevar items : list[TextAsset | ImageAsset | VideoAsset | AudioAsset | UrlAsset | HtmlAsset | MarkdownAsset | VastAsset | DaastAsset | CssAsset | JavascriptAsset | WebhookAsset]var model_config
Inherited members
class OptimizationGoal (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class OptimizationGoal(RootModel[OptimizationGoal1 | OptimizationGoal2]): root: Annotated[ OptimizationGoal1 | OptimizationGoal2, Field( description='A single optimization target for a package. Packages accept an array of optimization_goals. When multiple goals are present, priority determines which the seller focuses on — 1 is highest priority (primary goal); higher numbers are secondary. Duplicate priority values result in undefined seller behavior.', title='Optimization Goal', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[OptimizationGoal1, OptimizationGoal2]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : OptimizationGoal1 | OptimizationGoal2
class OutcomeMeasurement (**data: Any)-
Expand source code
class OutcomeMeasurement(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) attribution: Annotated[ str, Field( description='Attribution methodology', examples=['deterministic_purchase', 'probabilistic'], ), ] reporting: Annotated[ str, Field( description='Reporting frequency and format', examples=['weekly_dashboard', 'real_time_api'], ), ] type: Annotated[ str, Field( description='Type of measurement', examples=['incremental_sales_lift', 'brand_lift', 'foot_traffic'], ), ] window: Annotated[ duration.Duration | None, Field( description='Attribution window as a structured duration (e.g., {"interval": 30, "unit": "days"}).' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var attribution : strvar model_configvar reporting : strvar type : strvar window : Duration | None
Inherited members
class Overlay (**data: Any)-
Expand source code
class Overlay(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) bounds: Annotated[ Bounds, Field( description="Position and size of the overlay relative to the asset's own top-left corner. See 'unit' for coordinate interpretation." ), ] description: Annotated[ str | None, Field( description='Human-readable explanation of what this overlay is and how buyers should account for it' ), ] = None id: Annotated[ str, Field( description="Identifier for this overlay (e.g., 'play_pause', 'volume', 'publisher_logo', 'carousel_prev', 'carousel_next')" ), ] visual: Annotated[ Visual | None, Field( description='Optional visual reference for this overlay element. Useful for creative agents compositing previews and for buyers understanding what will appear over their content. Must include at least one of: url, light, or dark.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bounds : Boundsvar description : str | Nonevar id : strvar model_configvar visual : Visual | None
Inherited members
class Pacing (*args, **kwds)-
Expand source code
class Pacing(Enum): even = 'even' asap = 'asap' front_loaded = 'front_loaded'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var asapvar evenvar front_loaded
class MediaBuyPackage (**data: Any)-
Expand source code
class Package(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) bid_price: Annotated[ float | None, Field( description='Current bid price for auction-based packages. Denominated in package.currency when present, otherwise media_buy.currency. Relevant for automated price optimization loops.', ge=0.0, ), ] = None budget: Annotated[ float | None, Field( description='Package budget amount, denominated in package.currency when present, otherwise media_buy.currency', ge=0.0, ), ] = None canceled: Annotated[ bool | None, Field( description='Whether this package has been canceled. Canceled packages stop delivery and cannot be reactivated.' ), ] = None cancellation: Annotated[ Cancellation1 | None, Field(description='Cancellation metadata. Present only when canceled is true.'), ] = None creative_approvals: Annotated[ list[CreativeApproval] | None, Field( description='Approval status for each creative assigned to this package. Absent when no creatives have been assigned.' ), ] = None creative_deadline: Annotated[ AwareDatetime | None, Field( description="ISO 8601 timestamp for creative upload or change deadline for this package. After this deadline, creative changes are rejected. When absent, the media buy's creative_deadline applies." ), ] = None currency: Annotated[ str | None, Field( description='ISO 4217 currency code for monetary values at this package level (budget, bid_price, snapshot.spend). When absent, inherit media_buy.currency.', pattern='^[A-Z]{3}$', ), ] = None end_time: Annotated[ AwareDatetime | None, Field(description='ISO 8601 flight end time for this package') ] = None ext: ext_1.ExtensionObject | None = None format_ids_pending: Annotated[ list[format_id.FormatId] | None, Field( description='Format IDs from the original create_media_buy format_ids_to_provide that have not yet been uploaded via sync_creatives. When empty or absent, all required formats have been provided.' ), ] = None impressions: Annotated[ float | None, Field(description='Goal impression count for impression-based packages', ge=0.0), ] = None package_id: Annotated[str, Field(description="Seller's package identifier")] paused: Annotated[ bool | None, Field(description='Whether this package is currently paused by the buyer') ] = None product_id: Annotated[ str | None, Field(description='Product identifier this package is purchased from') ] = None snapshot: Annotated[ Snapshot | None, Field( description='Near-real-time delivery snapshot for this package. Only present when include_snapshot was true in the request. Represents the latest available entity-level stats from the platform — not billing-grade data.' ), ] = None snapshot_unavailable_reason: Annotated[ SnapshotUnavailableReason | None, Field( description='Machine-readable reason the snapshot is omitted. Present only when include_snapshot was true and snapshot is unavailable for this package.' ), ] = None start_time: Annotated[ AwareDatetime | None, Field( description='ISO 8601 flight start time for this package. Use to determine whether the package is within its scheduled flight before interpreting delivery status.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bid_price : float | Nonevar budget : float | Nonevar canceled : bool | Nonevar cancellation : Cancellation1 | Nonevar creative_approvals : list[CreativeApproval] | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar currency : str | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar format_ids_pending : list[FormatId] | Nonevar impressions : float | Nonevar model_configvar package_id : strvar paused : bool | Nonevar product_id : str | Nonevar snapshot : Snapshot | Nonevar start_time : pydantic.types.AwareDatetime | None
class Package (**data: Any)-
Expand source code
class Package(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) bid_price: Annotated[ float | None, Field( description="Bid price for auction-based pricing. This is the exact bid/price to honor unless the selected pricing option has max_bid=true, in which case bid_price is the buyer's maximum willingness to pay (ceiling).", ge=0.0, ), ] = None budget: Annotated[ float | None, Field( description='Budget allocation for this package in the currency specified by the pricing option', ge=0.0, ), ] = None canceled: Annotated[ bool | None, Field( description='Whether this package has been canceled. Canceled packages stop delivery and cannot be reactivated. Defaults to false.' ), ] = False cancellation: Annotated[ Cancellation | None, Field(description='Cancellation metadata. Present only when canceled is true.'), ] = None catalogs: Annotated[ list[catalog.Catalog] | None, Field( description='Catalogs this package promotes. Each catalog MUST have a distinct type (e.g., one product catalog, one store catalog). This constraint is enforced at the application level — sellers MUST reject requests containing multiple catalogs of the same type with a validation_error. Echoed from the create_media_buy request.' ), ] = None context: context_1.ContextObject | None = None creative_assignments: Annotated[ list[creative_assignment.CreativeAssignment] | None, Field(description='Creative assets assigned to this package'), ] = None creative_deadline: Annotated[ AwareDatetime | None, Field( description="ISO 8601 timestamp for creative upload or change deadline for this package. After this deadline, creative changes are rejected. When absent, the media buy's creative_deadline applies." ), ] = None end_time: Annotated[ AwareDatetime | None, Field( description="Flight end date/time for this package in ISO 8601 format. When omitted, the package inherits the media buy's end_time. Sellers SHOULD always include the resolved value in responses, even when inherited." ), ] = None ext: ext_1.ExtensionObject | None = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Format IDs active for this package. Echoed from the create_media_buy request; omitted means all formats for the product are active.' ), ] = None format_ids_to_provide: Annotated[ list[format_id.FormatId] | None, Field(description='Format IDs that creative assets will be provided for this package'), ] = None impressions: Annotated[ float | None, Field(description='Impression goal for this package', ge=0.0) ] = None optimization_goals: Annotated[ list[optimization_goal.OptimizationGoal] | None, Field( description='Optimization targets for this package. The seller optimizes delivery toward these goals in priority order. Common pattern: event goals (purchase, install) as primary targets at priority 1; metric goals (clicks, views) as secondary proxy signals at priority 2+.', min_length=1, ), ] = None pacing: pacing_1.Pacing | None = None package_id: Annotated[str, Field(description="Seller's unique identifier for the package")] paused: Annotated[ bool | None, Field( description='Whether this package is paused by the buyer. Paused packages do not deliver impressions. Defaults to false.' ), ] = False price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description="Breakdown of the effective price for this package. On fixed-price packages, echoes the pricing option's breakdown. On auction packages, shows the clearing price breakdown including any commission or settlement terms." ), ] = None pricing_option_id: Annotated[ str | None, Field( description="ID of the selected pricing option from the product's pricing_options array" ), ] = None product_id: Annotated[ str | None, Field(description='ID of the product this package is based on') ] = None start_time: Annotated[ AwareDatetime | None, Field( description="Flight start date/time for this package in ISO 8601 format. When omitted, the package inherits the media buy's start_time. Sellers SHOULD always include the resolved value in responses, even when inherited." ), ] = None targeting_overlay: targeting.TargetingOverlay | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bid_price : float | Nonevar budget : float | Nonevar canceled : bool | Nonevar cancellation : Cancellation | Nonevar catalogs : list[Catalog] | Nonevar context : ContextObject | Nonevar creative_assignments : list[CreativeAssignment] | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar format_ids : list[FormatId] | Nonevar format_ids_to_provide : list[FormatId] | Nonevar impressions : float | Nonevar model_configvar optimization_goals : list[OptimizationGoal] | Nonevar pacing : Pacing | Nonevar package_id : strvar paused : bool | Nonevar price_breakdown : PriceBreakdown | Nonevar pricing_option_id : str | Nonevar product_id : str | Nonevar start_time : pydantic.types.AwareDatetime | Nonevar targeting_overlay : TargetingOverlay | None
Inherited members
class PackageRequest (**data: Any)-
Expand source code
class PackageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) bid_price: Annotated[ float | None, Field( description="Bid price for auction-based pricing options. This is the exact bid/price to honor unless selected pricing_option has max_bid=true, in which case bid_price is the buyer's maximum willingness to pay (ceiling).", ge=0.0, ), ] = None budget: Annotated[ float, Field(description="Budget allocation for this package in the media buy's currency", ge=0.0), ] catalogs: Annotated[ list[catalog.Catalog] | None, Field( description='Catalogs this package promotes. Each catalog MUST have a distinct type (e.g., one product catalog, one store catalog). This constraint is enforced at the application level — sellers MUST reject requests containing multiple catalogs of the same type with a validation_error. Makes the package catalog-driven: one budget envelope, platform optimizes across items.' ), ] = None context: context_1.ContextObject | None = None creative_assignments: Annotated[ list[creative_assignment.CreativeAssignment] | None, Field( description='Assign existing library creatives to this package with optional weights and placement targeting', min_length=1, ), ] = None creatives: Annotated[ list[creative_asset.CreativeAsset] | None, Field( description='Upload new creative assets and assign to this package (creatives will be added to library). Use creative_assignments instead for existing library creatives.', max_length=100, min_length=1, ), ] = None end_time: Annotated[ AwareDatetime | None, Field( description="Flight end date/time for this package in ISO 8601 format. When omitted, the package inherits the media buy's end_time. Must fall within the media buy's date range." ), ] = None ext: ext_1.ExtensionObject | None = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Array of format IDs that will be used for this package - must be supported by the product. If omitted, defaults to all formats supported by the product.', min_length=1, ), ] = None impressions: Annotated[ float | None, Field(description='Impression goal for this package', ge=0.0) ] = None optimization_goals: Annotated[ list[optimization_goal.OptimizationGoal] | None, Field( description='Optimization targets for this package. The seller optimizes delivery toward these goals in priority order. Common pattern: event goals (purchase, install) as primary targets at priority 1; metric goals (clicks, views) as secondary proxy signals at priority 2+.', min_length=1, ), ] = None pacing: pacing_1.Pacing | None = None paused: Annotated[ bool | None, Field( description='Whether this package should be created in a paused state. Paused packages do not deliver impressions. Defaults to false.' ), ] = False pricing_option_id: Annotated[ str, Field( description="ID of the selected pricing option from the product's pricing_options array" ), ] product_id: Annotated[str, Field(description='Product ID for this package')] start_time: Annotated[ AwareDatetime | None, Field( description="Flight start date/time for this package in ISO 8601 format. When omitted, the package inherits the media buy's start_time. Must fall within the media buy's date range." ), ] = None targeting_overlay: targeting.TargetingOverlay | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bid_price : float | Nonevar budget : floatvar catalogs : list[Catalog] | Nonevar context : ContextObject | Nonevar creative_assignments : list[CreativeAssignment] | Nonevar creatives : list[CreativeAsset] | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar format_ids : list[FormatId] | Nonevar impressions : float | Nonevar model_configvar optimization_goals : list[OptimizationGoal] | Nonevar pacing : Pacing | Nonevar paused : bool | Nonevar pricing_option_id : strvar product_id : strvar start_time : pydantic.types.AwareDatetime | Nonevar targeting_overlay : TargetingOverlay | None
Inherited members
class PackageUpdate (**data: Any)-
Expand source code
class PackageUpdate(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) bid_price: Annotated[ float | None, Field( description="Updated bid price for auction-based pricing options. This is the exact bid/price to honor unless selected pricing_option has max_bid=true, in which case bid_price is the buyer's maximum willingness to pay (ceiling).", ge=0.0, ), ] = None budget: Annotated[ float | None, Field( description='Updated budget allocation for this package in the currency specified by the pricing option', ge=0.0, ), ] = None canceled: Annotated[ Literal[True], Field( description='Cancel this specific package. Cancellation is irreversible — canceled packages stop delivery and cannot be reactivated. Sellers MAY reject with NOT_CANCELLABLE.' ), ] = True cancellation_reason: Annotated[ str | None, Field(description='Reason for canceling this package.', max_length=500) ] = None catalogs: Annotated[ list[catalog.Catalog] | None, Field( description='Replace the catalogs this package promotes. Uses replacement semantics — the provided array replaces the current list. Omit to leave catalogs unchanged.', min_length=1, ), ] = None context: context_1.ContextObject | None = None creative_assignments: Annotated[ list[creative_assignment.CreativeAssignment] | None, Field( description='Replace creative assignments for this package with optional weights and placement targeting. Uses replacement semantics - omit to leave assignments unchanged.' ), ] = None creatives: Annotated[ list[creative_asset.CreativeAsset] | None, Field( description='Upload new creative assets and assign to this package (creatives will be added to library). Use creative_assignments instead for existing library creatives.', max_length=100, min_length=1, ), ] = None end_time: Annotated[ AwareDatetime | None, Field( description="Updated flight end date/time for this package in ISO 8601 format. Must fall within the media buy's date range." ), ] = None ext: ext_1.ExtensionObject | None = None impressions: Annotated[ float | None, Field(description='Updated impression goal for this package', ge=0.0) ] = None keyword_targets_add: Annotated[ list[KeywordTargetsAddItem] | None, Field( description='Keyword targets to add or update on this package. Upserts by (keyword, match_type) identity: if the pair already exists, its bid_price is updated; if not, a new keyword target is added. Use targeting_overlay.keyword_targets in create_media_buy to set the initial list.', min_length=1, ), ] = None keyword_targets_remove: Annotated[ list[KeywordTargetsRemoveItem] | None, Field( description='Keyword targets to remove from this package. Removes matching (keyword, match_type) pairs. If a specified pair is not present, sellers SHOULD treat it as a no-op for that entry.', min_length=1, ), ] = None negative_keywords_add: Annotated[ list[NegativeKeywordsAddItem] | None, Field( description='Negative keywords to add to this package. Appends to the existing negative keyword list — does not replace it. If a keyword+match_type pair already exists, sellers SHOULD treat it as a no-op for that entry. Use targeting_overlay.negative_keywords in create_media_buy to set the initial list.', min_length=1, ), ] = None negative_keywords_remove: Annotated[ list[NegativeKeywordsRemoveItem] | None, Field( description='Negative keywords to remove from this package. Removes matching keyword+match_type pairs from the existing list. If a specified pair is not present, sellers SHOULD treat it as a no-op for that entry.', min_length=1, ), ] = None optimization_goals: Annotated[ list[optimization_goal.OptimizationGoal] | None, Field( description='Replace all optimization goals for this package. Uses replacement semantics — omit to leave goals unchanged.', min_length=1, ), ] = None pacing: pacing_1.Pacing | None = None package_id: Annotated[str, Field(description="Seller's ID of package to update")] paused: Annotated[ bool | None, Field(description='Pause/resume specific package (true = paused, false = active)'), ] = None start_time: Annotated[ AwareDatetime | None, Field( description="Updated flight start date/time for this package in ISO 8601 format. Must fall within the media buy's date range." ), ] = None targeting_overlay: Annotated[ targeting.TargetingOverlay | None, Field( description='Targeting overlay to apply to this package. Uses replacement semantics — the full overlay replaces the previous one. Omit to leave targeting unchanged. For keyword and negative keyword updates, prefer the incremental operations (keyword_targets_add, keyword_targets_remove, negative_keywords_add, negative_keywords_remove) which avoid replacing the full overlay. Sellers SHOULD return a validation error if targeting_overlay.keyword_targets is present in the same request as keyword_targets_add or keyword_targets_remove, and likewise for negative_keywords.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var bid_price : float | Nonevar budget : float | Nonevar canceled : Literal[True]var cancellation_reason : str | Nonevar catalogs : list[Catalog] | Nonevar context : ContextObject | Nonevar creative_assignments : list[CreativeAssignment] | Nonevar creatives : list[CreativeAsset] | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar impressions : float | Nonevar keyword_targets_add : list[KeywordTargetsAddItem] | Nonevar keyword_targets_remove : list[KeywordTargetsRemoveItem] | Nonevar model_configvar negative_keywords_add : list[NegativeKeywordsAddItem] | Nonevar negative_keywords_remove : list[NegativeKeywordsRemoveItem] | Nonevar optimization_goals : list[OptimizationGoal] | Nonevar pacing : Pacing | Nonevar package_id : strvar paused : bool | Nonevar start_time : pydantic.types.AwareDatetime | Nonevar targeting_overlay : TargetingOverlay | None
Inherited members
class Pagination (**data: Any)-
Expand source code
class Pagination(AdCPBaseModel): batch_number: Annotated[int | None, Field(description='Current batch number (1-indexed)')] = ( None ) total_artifacts: Annotated[ int | None, Field(description='Total artifacts in the delivery period') ] = None total_batches: Annotated[ int | None, Field(description='Total batches for this delivery period') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var batch_number : int | Nonevar model_configvar total_artifacts : int | Nonevar total_batches : int | None
Inherited members
class PaginationRequest (**data: Any)-
Expand source code
class PaginationRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) cursor: Annotated[ str | None, Field(description='Opaque cursor from a previous response to fetch the next page'), ] = None max_results: Annotated[ int | None, Field(description='Maximum number of items to return per page', ge=1, le=100) ] = 50Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var cursor : str | Nonevar max_results : int | Nonevar model_config
Inherited members
class Parameters (**data: Any)-
Expand source code
class Parameters(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) demographic: Annotated[ str, Field( description='Target demographic code within the specified demographic_system (e.g., P18-49 for Nielsen, ABC1 Adults for BARB)' ), ] demographic_system: Annotated[ demographic_system_1.DemographicSystem | None, Field( description='Measurement system for the demographic field. Defaults to nielsen when omitted.' ), ] = None min_points: Annotated[float | None, Field(description='Minimum GRPs/TRPs required', ge=0.0)] = ( None )Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var demographic : strvar demographic_system : DemographicSystem | Nonevar min_points : float | Nonevar model_config
Inherited members
class PerformanceFeedback (**data: Any)-
Expand source code
class PerformanceFeedback(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) applied_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when feedback was applied to optimization algorithms' ), ] = None creative_id: Annotated[ str | None, Field(description='Specific creative asset (if feedback is creative-specific)') ] = None feedback_id: Annotated[ str, Field(description='Unique identifier for this performance feedback submission') ] feedback_source: Annotated[ feedback_source_1.FeedbackSource, Field(description='Source of the performance data') ] measurement_period: Annotated[ MeasurementPeriod, Field(description='Time period for performance measurement') ] media_buy_id: Annotated[str, Field(description="Publisher's media buy identifier")] metric_type: Annotated[ metric_type_1.MetricType, Field(description='The business metric being measured') ] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)' ), ] = None performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] status: Annotated[Status, Field(description='Processing status of the performance feedback')] submitted_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when feedback was submitted') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var applied_at : pydantic.types.AwareDatetime | Nonevar creative_id : str | Nonevar feedback_id : strvar feedback_source : FeedbackSourcevar measurement_period : MeasurementPeriodvar media_buy_id : strvar metric_type : MetricTypevar model_configvar package_id : str | Nonevar performance_index : floatvar status : Statusvar submitted_at : pydantic.types.AwareDatetime
class Performance (**data: Any)-
Expand source code
class PerformanceFeedback(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) applied_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when feedback was applied to optimization algorithms' ), ] = None creative_id: Annotated[ str | None, Field(description='Specific creative asset (if feedback is creative-specific)') ] = None feedback_id: Annotated[ str, Field(description='Unique identifier for this performance feedback submission') ] feedback_source: Annotated[ feedback_source_1.FeedbackSource, Field(description='Source of the performance data') ] measurement_period: Annotated[ MeasurementPeriod, Field(description='Time period for performance measurement') ] media_buy_id: Annotated[str, Field(description="Publisher's media buy identifier")] metric_type: Annotated[ metric_type_1.MetricType, Field(description='The business metric being measured') ] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)' ), ] = None performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] status: Annotated[Status, Field(description='Processing status of the performance feedback')] submitted_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when feedback was submitted') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var applied_at : pydantic.types.AwareDatetime | Nonevar creative_id : str | Nonevar feedback_id : strvar feedback_source : FeedbackSourcevar measurement_period : MeasurementPeriodvar media_buy_id : strvar metric_type : MetricTypevar model_configvar package_id : str | Nonevar performance_index : floatvar status : Statusvar submitted_at : pydantic.types.AwareDatetime
Inherited members
class Placement (**data: Any)-
Expand source code
class Placement(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) description: Annotated[ str | None, Field(description='Detailed description of where and how the placement appears') ] = None format_ids: Annotated[ list[format_id.FormatId] | None, Field( description='Format IDs supported by this specific placement. Can include: (1) concrete format_ids (fixed dimensions), (2) template format_ids without parameters (accepts any dimensions/duration), or (3) parameterized format_ids (specific dimension/duration constraints).', min_length=1, ), ] = None name: Annotated[ str, Field( description="Human-readable name for the placement (e.g., 'Homepage Banner', 'Article Sidebar')" ), ] placement_id: Annotated[ str, Field(description='Unique identifier for the placement within the product') ] tags: Annotated[ list[str] | None, Field( description="Optional tags for grouping placements within a product (e.g., 'homepage', 'native', 'premium'). When the placement_id comes from the publisher registry, these should align with the registry tags unless the product is narrowing scope." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var description : str | Nonevar format_ids : list[FormatId] | Nonevar model_configvar name : strvar placement_id : str
Inherited members
class Policy (**data: Any)-
Expand source code
class Policy(PolicySummary): """Full governance policy including policy text and calibration exemplars.""" policy: str guidance: str | None = None exemplars: PolicyExemplars | None = None ext: dict[str, Any] | None = NoneFull governance policy including policy text and calibration exemplars.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- PolicySummary
- pydantic.main.BaseModel
Class variables
var exemplars : PolicyExemplars | Nonevar ext : dict[str, typing.Any] | Nonevar guidance : str | Nonevar model_configvar policy : str
class PolicyExemplar (**data: Any)-
Expand source code
class PolicyExemplar(BaseModel): """A pass/fail scenario used to calibrate governance agent interpretation.""" model_config = ConfigDict(extra="allow") scenario: str explanation: strA pass/fail scenario used to calibrate governance agent interpretation.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var explanation : strvar model_configvar scenario : str
class PolicyExemplars (**data: Any)-
Expand source code
class PolicyExemplars(BaseModel): """Collection of pass/fail exemplars for a policy.""" model_config = ConfigDict(extra="allow") pass_: list[PolicyExemplar] = Field(default_factory=list, alias="pass") fail: list[PolicyExemplar] = Field(default_factory=list)Collection of pass/fail exemplars for a policy.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var fail : list[PolicyExemplar]var model_configvar pass_ : list[PolicyExemplar]
class PolicyHistory (**data: Any)-
Expand source code
class PolicyHistory(BaseModel): """Edit history for a policy.""" model_config = ConfigDict(extra="allow") policy_id: str total: int revisions: list[PolicyRevision] = Field(default_factory=list)Edit history for a policy.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var model_configvar policy_id : strvar revisions : list[PolicyRevision]var total : int
class PolicyRevision (**data: Any)-
Expand source code
class PolicyRevision(BaseModel): """A single revision in a policy's edit history.""" model_config = ConfigDict(extra="allow") revision_number: int editor_name: str edit_summary: str is_rollback: bool rolled_back_to: int | None = None created_at: strA single revision in a policy's edit history.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var created_at : strvar edit_summary : strvar editor_name : strvar is_rollback : boolvar model_configvar revision_number : intvar rolled_back_to : int | None
class PolicySummary (**data: Any)-
Expand source code
class PolicySummary(BaseModel): """Summary of a governance policy from the registry.""" model_config = ConfigDict(extra="allow", populate_by_name=True) policy_id: str version: str name: str description: str | None = None category: str enforcement: str jurisdictions: list[str] = Field(default_factory=list) region_aliases: dict[str, list[str]] = Field(default_factory=dict) verticals: list[str] = Field(default_factory=list) channels: list[str] | None = None governance_domains: list[str] = Field(default_factory=list) effective_date: str | None = None sunset_date: str | None = None source_url: str | None = None source_name: str | None = None source_type: str | None = None review_status: str | None = None created_at: str | None = None updated_at: str | None = NoneSummary of a governance policy from the 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Subclasses
Class variables
var category : strvar channels : list[str] | Nonevar created_at : str | Nonevar description : str | Nonevar effective_date : str | Nonevar enforcement : strvar governance_domains : list[str]var jurisdictions : list[str]var model_configvar name : strvar policy_id : strvar region_aliases : dict[str, list[str]]var review_status : str | Nonevar source_name : str | Nonevar source_type : str | Nonevar source_url : str | Nonevar sunset_date : str | Nonevar updated_at : str | Nonevar version : strvar verticals : list[str]
class Preview (**data: Any)-
Expand source code
class Preview(AdCPBaseModel): input: Annotated[ Input, Field( description='The input parameters that generated this preview variant. Echoes back the request input or shows defaults used.' ), ] preview_id: Annotated[str, Field(description='Unique identifier for this preview variant')] renders: Annotated[ list[preview_render.PreviewRender], Field( description='Array of rendered pieces for this preview variant. Most formats render as a single piece. Companion ad formats (video + banner), multi-placement formats, and adaptive formats render as multiple pieces.', min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var input : Inputvar model_configvar preview_id : strvar renders : list[PreviewRender]
Inherited members
class PreviewCreativeSingleRequest (**data: Any)-
Expand source code
class PreviewCreativeRequest1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets for the format.'), ] ext: ext_1.ExtensionObject | None = None format_id: Annotated[ format_id_1.FormatId | None, Field( description='Format identifier for rendering the preview. Optional — defaults to creative_manifest_1.format_id if omitted.' ), ] = None inputs: Annotated[ list[Input] | None, Field( description='Array of input sets for generating multiple preview variants. Each input set defines macros and context values for one preview rendering. If not provided, creative agent will generate default previews.', min_length=1, ), ] = None item_limit: Annotated[ int | None, Field( description="Maximum number of catalog items to render in the preview. For catalog-driven generative formats, caps how many items are rendered per preview variant. When item_limit exceeds the format's max_items, the creative agent SHOULD use the lesser of the two. Ignored when the manifest contains no catalog assets. Creative agents SHOULD default to a reasonable sample when omitted and the catalog is large.", ge=1, ), ] = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Output format for previews. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML for direct embedding). Default: 'url' for backward compatibility." ), ] = preview_output_format.PreviewOutputFormat.url quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Render quality for the preview. 'draft' produces fast, lower-fidelity renderings for rapid iteration. 'production' produces full-quality renderings for final review. If omitted, the creative agent uses its own default." ), ] = None request_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview request'), ] template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_manifest : CreativeManifestvar ext : ExtensionObject | Nonevar format_id : FormatId | Nonevar inputs : list[Input] | Nonevar item_limit : int | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar quality : CreativeQuality | Nonevar request_type : Literal['single']var template_id : str | None
class PreviewCreativeFormatRequest (**data: Any)-
Expand source code
class PreviewCreativeRequest1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets for the format.'), ] ext: ext_1.ExtensionObject | None = None format_id: Annotated[ format_id_1.FormatId | None, Field( description='Format identifier for rendering the preview. Optional — defaults to creative_manifest_1.format_id if omitted.' ), ] = None inputs: Annotated[ list[Input] | None, Field( description='Array of input sets for generating multiple preview variants. Each input set defines macros and context values for one preview rendering. If not provided, creative agent will generate default previews.', min_length=1, ), ] = None item_limit: Annotated[ int | None, Field( description="Maximum number of catalog items to render in the preview. For catalog-driven generative formats, caps how many items are rendered per preview variant. When item_limit exceeds the format's max_items, the creative agent SHOULD use the lesser of the two. Ignored when the manifest contains no catalog assets. Creative agents SHOULD default to a reasonable sample when omitted and the catalog is large.", ge=1, ), ] = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Output format for previews. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML for direct embedding). Default: 'url' for backward compatibility." ), ] = preview_output_format.PreviewOutputFormat.url quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Render quality for the preview. 'draft' produces fast, lower-fidelity renderings for rapid iteration. 'production' produces full-quality renderings for final review. If omitted, the creative agent uses its own default." ), ] = None request_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview request'), ] template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_manifest : CreativeManifestvar ext : ExtensionObject | Nonevar format_id : FormatId | Nonevar inputs : list[Input] | Nonevar item_limit : int | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar quality : CreativeQuality | Nonevar request_type : Literal['single']var template_id : str | None
Inherited members
class PreviewCreativeBatchRequest (**data: Any)-
Expand source code
class PreviewCreativeRequest2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Default output format for all requests in this batch. Individual requests can override this. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML for direct embedding)." ), ] = preview_output_format.PreviewOutputFormat.url quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Default render quality for all requests in this batch. Individual requests can override this. 'draft' produces fast, lower-fidelity renderings. 'production' produces full-quality renderings." ), ] = None request_type: Annotated[ Literal['batch'], Field(description='Discriminator indicating this is a batch preview request'), ] requests: Annotated[ list[Request], Field( description='Array of preview requests (1-50 items). Each follows the single request structure.', max_length=50, min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar quality : CreativeQuality | Nonevar request_type : Literal['batch']var requests : list[Request]
class PreviewCreativeManifestRequest (**data: Any)-
Expand source code
class PreviewCreativeRequest2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Default output format for all requests in this batch. Individual requests can override this. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML for direct embedding)." ), ] = preview_output_format.PreviewOutputFormat.url quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Default render quality for all requests in this batch. Individual requests can override this. 'draft' produces fast, lower-fidelity renderings. 'production' produces full-quality renderings." ), ] = None request_type: Annotated[ Literal['batch'], Field(description='Discriminator indicating this is a batch preview request'), ] requests: Annotated[ list[Request], Field( description='Array of preview requests (1-50 items). Each follows the single request structure.', max_length=50, min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar quality : CreativeQuality | Nonevar request_type : Literal['batch']var requests : list[Request]
Inherited members
class PreviewCreativeVariantRequest (**data: Any)-
Expand source code
class PreviewCreativeRequest3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_id: Annotated[str | None, Field(description='Creative identifier for context')] = None ext: ext_1.ExtensionObject | None = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Output format for the preview. 'url' returns preview_url (iframe-embeddable URL), 'html' returns preview_html (raw HTML for direct embedding)." ), ] = preview_output_format.PreviewOutputFormat.url request_type: Annotated[ Literal['variant'], Field(description='Discriminator indicating this is a variant preview request'), ] variant_id: Annotated[ str, Field( description='Platform-assigned variant identifier from get_creative_delivery response' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar request_type : Literal['variant']var variant_id : str
Inherited members
class PreviewCreativeSingleResponse (**data: Any)-
Expand source code
class PreviewCreativeResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None expires_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when preview links expire') ] ext: ext_1.ExtensionObject | None = None interactive_url: Annotated[ AnyUrl | None, Field( description='Optional URL to an interactive testing page that shows all preview variants with controls to switch between them, modify macro values, and test different scenarios.' ), ] = None previews: Annotated[ list[Preview], Field( description='Array of preview variants. Each preview corresponds to an input set from the request. If no inputs were provided, returns a single default preview.', min_length=1, ), ] response_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview response'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar expires_at : pydantic.types.AwareDatetimevar ext : ExtensionObject | Nonevar interactive_url : pydantic.networks.AnyUrl | Nonevar model_configvar previews : list[Preview]var response_type : Literal['single']
class PreviewCreativeStaticResponse (**data: Any)-
Expand source code
class PreviewCreativeResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None expires_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when preview links expire') ] ext: ext_1.ExtensionObject | None = None interactive_url: Annotated[ AnyUrl | None, Field( description='Optional URL to an interactive testing page that shows all preview variants with controls to switch between them, modify macro values, and test different scenarios.' ), ] = None previews: Annotated[ list[Preview], Field( description='Array of preview variants. Each preview corresponds to an input set from the request. If no inputs were provided, returns a single default preview.', min_length=1, ), ] response_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview response'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar expires_at : pydantic.types.AwareDatetimevar ext : ExtensionObject | Nonevar interactive_url : pydantic.networks.AnyUrl | Nonevar model_configvar previews : list[Preview]var response_type : Literal['single']
Inherited members
class PreviewCreativeBatchResponse (**data: Any)-
Expand source code
class PreviewCreativeResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None response_type: Annotated[ Literal['batch'], Field(description='Discriminator indicating this is a batch preview response'), ] results: Annotated[ list[Results | Results1], Field( description='Array of preview results corresponding to each request in the same order. results[0] is the result for requests[0], results[1] for requests[1], etc. Order is guaranteed even when some requests fail. Each result contains either a successful preview response or an error.', min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar response_type : Literal['batch']var results : list[Results | Results1]
class PreviewCreativeInteractiveResponse (**data: Any)-
Expand source code
class PreviewCreativeResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None response_type: Annotated[ Literal['batch'], Field(description='Discriminator indicating this is a batch preview response'), ] results: Annotated[ list[Results | Results1], Field( description='Array of preview results corresponding to each request in the same order. results[0] is the result for requests[0], results[1] for requests[1], etc. Order is guaranteed even when some requests fail. Each result contains either a successful preview response or an error.', min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar response_type : Literal['batch']var results : list[Results | Results1]
Inherited members
class PreviewCreativeVariantResponse (**data: Any)-
Expand source code
class PreviewCreativeResponse3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_id: Annotated[ str | None, Field(description='Creative identifier this variant belongs to') ] = None expires_at: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp when preview links expire') ] = None ext: ext_1.ExtensionObject | None = None manifest: Annotated[ creative_manifest.CreativeManifest | None, Field( description='The rendered creative manifest for this variant — the actual output that was served, not the input assets' ), ] = None previews: Annotated[ list[Preview7], Field( description='Array of rendered pieces for this variant. Most formats render as a single piece.', min_length=1, ), ] response_type: Annotated[ Literal['variant'], Field(description='Discriminator indicating this is a variant preview response'), ] variant_id: Annotated[str, Field(description='Platform-assigned variant identifier')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_id : str | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar manifest : CreativeManifest | Nonevar model_configvar previews : list[Preview7]var response_type : Literal['variant']var variant_id : str
Inherited members
class PreviewOutputFormat (*args, **kwds)-
Expand source code
class PreviewOutputFormat(Enum): url = 'url' html = 'html'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var htmlvar url
class OutputFormat (*args, **kwds)-
Expand source code
class PreviewOutputFormat(Enum): url = 'url' html = 'html'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var htmlvar url
class PreviewRender (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class PreviewRender(RootModel[PreviewRender1 | PreviewRender2 | PreviewRender3]): root: Annotated[ PreviewRender1 | PreviewRender2 | PreviewRender3, Field( description='A single rendered piece of a creative preview with discriminated output format', title='Preview Render', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[PreviewRender1, PreviewRender2, PreviewRender3]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : PreviewRender1 | PreviewRender2 | PreviewRender3
class UrlPreviewRender (**data: Any)-
Expand source code
class PreviewRender1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) dimensions: Annotated[ Dimensions | None, Field(description='Dimensions for this rendered piece') ] = None embedding: Annotated[ Embedding | None, Field(description='Optional security and embedding metadata for safe iframe integration'), ] = None output_format: Annotated[ Literal['url'], Field(description='Discriminator indicating preview_url is provided') ] preview_url: Annotated[ AnyUrl, Field( description='URL to an HTML page that renders this piece. Can be embedded in an iframe.' ), ] render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] role: Annotated[ str, Field( description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var dimensions : Dimensions | Nonevar embedding : Embedding | Nonevar model_configvar output_format : Literal['url']var preview_url : pydantic.networks.AnyUrlvar render_id : strvar role : str
Inherited members
class HtmlPreviewRender (**data: Any)-
Expand source code
class PreviewRender2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) dimensions: Annotated[ Dimensions | None, Field(description='Dimensions for this rendered piece') ] = None embedding: Annotated[ Embedding | None, Field(description='Optional security and embedding metadata') ] = None output_format: Annotated[ Literal['html'], Field(description='Discriminator indicating preview_html is provided') ] preview_html: Annotated[ str, Field( description='Raw HTML for this rendered piece. Can be embedded directly in the page without iframe. Security warning: Only use with trusted creative agents as this bypasses iframe sandboxing.' ), ] render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] role: Annotated[ str, Field( description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var dimensions : Dimensions | Nonevar embedding : Embedding | Nonevar model_configvar output_format : Literal['html']var preview_html : strvar render_id : strvar role : str
Inherited members
class BothPreviewRender (**data: Any)-
Expand source code
class PreviewRender3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) dimensions: Annotated[ Dimensions | None, Field(description='Dimensions for this rendered piece') ] = None embedding: Annotated[ Embedding | None, Field(description='Optional security and embedding metadata for safe iframe integration'), ] = None output_format: Annotated[ Literal['both'], Field( description='Discriminator indicating both preview_url and preview_html are provided' ), ] preview_html: Annotated[ str, Field( description='Raw HTML for this rendered piece. Can be embedded directly in the page without iframe. Security warning: Only use with trusted creative agents as this bypasses iframe sandboxing.' ), ] preview_url: Annotated[ AnyUrl, Field( description='URL to an HTML page that renders this piece. Can be embedded in an iframe.' ), ] render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] role: Annotated[ str, Field( description="Semantic role of this rendered piece. Use 'primary' for main content, 'companion' for associated banners, descriptive strings for device variants or custom roles." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var dimensions : Dimensions | Nonevar embedding : Embedding | Nonevar model_configvar output_format : Literal['both']var preview_html : strvar preview_url : pydantic.networks.AnyUrlvar render_id : strvar role : str
Inherited members
class PriceGuidance (**data: Any)-
Expand source code
class PriceGuidance(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) p25: Annotated[ float | None, Field(description='25th percentile of recent winning bids', ge=0.0) ] = None p50: Annotated[float | None, Field(description='Median of recent winning bids', ge=0.0)] = None p75: Annotated[ float | None, Field(description='75th percentile of recent winning bids', ge=0.0) ] = None p90: Annotated[ float | None, Field(description='90th percentile of recent winning bids', ge=0.0) ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar p25 : float | Nonevar p50 : float | Nonevar p75 : float | Nonevar p90 : float | None
Inherited members
class PricingModel (*args, **kwds)-
Expand source code
class PricingModel(Enum): cpm = 'cpm' vcpm = 'vcpm' cpc = 'cpc' cpcv = 'cpcv' cpv = 'cpv' cpp = 'cpp' cpa = 'cpa' flat_rate = 'flat_rate' time = 'time'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var cpavar cpcvar cpcvvar cpmvar cppvar cpvvar flat_ratevar timevar vcpm
class PrimaryCountry (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class PrimaryCountry(RootModel[str]): root: Annotated[str, Field(pattern='^[A-Z]{2}$')]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : str
class Product (**data: Any)-
Expand source code
class Product(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) brief_relevance: Annotated[ str | None, Field( description='Explanation of why this product matches the brief (only included when brief is provided)' ), ] = None catalog_match: Annotated[ CatalogMatch | None, Field( description='When the buyer provides a catalog on get_products, indicates which catalog items are eligible for this product. Only present for products where catalog matching is relevant (e.g., sponsored product listings, job boards, hotel ads).' ), ] = None catalog_types: Annotated[ list[catalog_type.CatalogType] | None, Field( description='Catalog types this product supports for catalog-driven campaigns. A sponsored product listing declares ["product"], a job board declares ["job", "offering"]. Buyers match synced catalogs to products via this field.', min_length=1, ), ] = None channels: Annotated[ list[channels_1.MediaChannel] | None, Field( description="Advertising channels this product is sold as. Products inherit from their properties' supported_channels but may narrow the scope. For example, a product covering YouTube properties might be sold as ['ctv'] even though those properties support ['olv', 'social', 'ctv']." ), ] = None collection_targeting_allowed: Annotated[ bool | None, Field( description="Whether buyers can target a subset of this product's collections. When false (default), the product is a bundle — buyers get all listed collections. When true, buyers can select specific collections in the media buy." ), ] = False collections: Annotated[ list[collection_selector.CollectionSelector] | None, Field( description='Collections available in this product. Each entry references collections declared in an adagents.json by domain and collection ID. Buyers resolve full collection objects from the referenced adagents.json.', min_length=1, ), ] = None conversion_tracking: Annotated[ ConversionTracking | None, Field( description="Conversion event tracking for this product. Presence indicates the product supports optimization_goals with kind: 'event'. Seller-level capabilities (supported event types, UID types, attribution windows) are declared in get_adcp_capabilities." ), ] = None creative_policy: creative_policy_1.CreativePolicy | None = None data_provider_signals: Annotated[ list[data_provider_signal_selector.DataProviderSignalSelector] | None, Field( description="Data provider signals available for this product. Buyers fetch signal definitions from each data provider's adagents.json and can verify agent authorization." ), ] = None delivery_measurement: Annotated[ DeliveryMeasurement | None, Field( description='Measurement provider and methodology for delivery metrics. The buyer accepts the declared provider as the source of truth for the buy. When absent, buyers should apply their own measurement defaults.' ), ] = None delivery_type: delivery_type_1.DeliveryType description: Annotated[ str, Field(description='Detailed description of the product and its inventory') ] enforced_policies: Annotated[ list[str] | None, Field( description='Registry policy IDs the seller enforces for this product. Enforcement level comes from the policy registry. Buyers can filter products by required policies.' ), ] = None exclusivity: Annotated[ exclusivity_1.Exclusivity | None, Field( description="Whether this product offers exclusive access to its inventory. Defaults to 'none' when absent. Most relevant for guaranteed products tied to specific collections or placements." ), ] = None expires_at: Annotated[ AwareDatetime | None, Field( description='Expiration timestamp. After this time, the product may no longer be available for purchase and create_media_buy may reject packages referencing it.' ), ] = None ext: ext_1.ExtensionObject | None = None forecast: Annotated[ delivery_forecast.DeliveryForecast | None, Field( description='Forecasted delivery metrics for this product. Gives buyers an estimate of expected performance before requesting a proposal.' ), ] = None format_ids: Annotated[ list[format_id_1.FormatId], Field( description='Array of supported creative format IDs - structured format_id objects with agent_url and id' ), ] installments: Annotated[ list[installment.Installment] | None, Field( description='Specific installments included in this product. Each installment references its parent collection via collection_id when the product spans multiple collections. When absent with collections present, the product covers the collections broadly (run-of-collection).' ), ] = None is_custom: Annotated[bool | None, Field(description='Whether this is a custom product')] = None material_submission: Annotated[ MaterialSubmission | None, Field( description="Instructions for submitting physical creative materials (print, static OOH, cinema). Present only for products requiring physical delivery outside the digital creative assignment flow. Buyer agents MUST validate url and email domains against the seller's known domains (from adagents.json) before submitting materials. Never auto-submit without human confirmation." ), ] = None max_optimization_goals: Annotated[ int | None, Field( description='Maximum number of optimization_goals this product accepts on a package. When absent, no limit is declared. Most social platforms accept only 1 goal — buyers sending arrays longer than this value should expect the seller to use only the highest-priority (lowest priority number) goal.', ge=1, ), ] = None measurement_readiness: Annotated[ measurement_readiness_1.MeasurementReadiness | None, Field( description="Assessment of whether the buyer's event source setup is sufficient for this product to optimize effectively. Only present when the seller can evaluate the buyer's account context. Buyers should check this before creating media buys with event-based optimization goals." ), ] = None metric_optimization: Annotated[ MetricOptimization | None, Field( description="Metric optimization capabilities for this product. Presence indicates the product supports optimization_goals with kind: 'metric'. No event source or conversion tracking setup required — the seller tracks these metrics natively." ), ] = None name: Annotated[str, Field(description='Human-readable product name')] outcome_measurement: outcome_measurement_1.OutcomeMeasurement | None = None placements: Annotated[ list[placement.Placement] | None, Field( description='Optional array of specific placements within this product. When provided, buyers can target specific placements when assigning creatives.', min_length=1, ), ] = None pricing_options: Annotated[ list[pricing_option.PricingOption], Field(description='Available pricing models for this product', min_length=1), ] product_card: Annotated[ ProductCard | None, Field( description='Optional standard visual card (300x400px) for displaying this product in user interfaces. Can be rendered via preview_creative or pre-generated.' ), ] = None product_card_detailed: Annotated[ ProductCardDetailed | None, Field( description='Optional detailed card with carousel and full specifications. Provides rich product presentation similar to media kit pages.' ), ] = None product_id: Annotated[str, Field(description='Unique identifier for the product')] property_targeting_allowed: Annotated[ bool | None, Field( description="Whether buyers can filter this product to a subset of its publisher_properties. When false (default), the product is 'all or nothing' - buyers must accept all properties or the product is excluded from property_list filtering results." ), ] = False publisher_properties: Annotated[ list[publisher_property_selector.PublisherPropertySelector], Field( description="Publisher properties covered by this product. Buyers fetch actual property definitions from each publisher's adagents.json and validate agent authorization. Selection patterns mirror the authorization patterns in adagents.json for consistency.", min_length=1, ), ] reporting_capabilities: reporting_capabilities_1.ReportingCapabilities | None = None signal_targeting_allowed: Annotated[ bool | None, Field( description='Whether buyers can filter this product to a subset of its data_provider_signals. When false (default), the product includes all listed signals as a bundle. When true, buyers can target specific signals.' ), ] = False trusted_match: Annotated[ TrustedMatch | None, Field( description='Trusted Match Protocol capabilities for this product. When present, the product supports real-time contextual and/or identity matching via TMP. Buyers use this to determine what response types the publisher can accept and whether brands can be selected dynamically at match time.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var brief_relevance : str | Nonevar catalog_match : CatalogMatch | Nonevar catalog_types : list[CatalogType] | Nonevar channels : list[MediaChannel] | Nonevar collection_targeting_allowed : bool | Nonevar collections : list[CollectionSelector] | Nonevar conversion_tracking : ConversionTracking | Nonevar creative_policy : CreativePolicy | Nonevar data_provider_signals : list[DataProviderSignalSelector] | Nonevar delivery_measurement : DeliveryMeasurement | Nonevar delivery_type : DeliveryTypevar description : strvar enforced_policies : list[str] | Nonevar exclusivity : Exclusivity | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar forecast : DeliveryForecast | Nonevar format_ids : list[FormatId]var installments : list[Installment] | Nonevar is_custom : bool | Nonevar material_submission : MaterialSubmission | Nonevar max_optimization_goals : int | Nonevar measurement_readiness : MeasurementReadiness | Nonevar metric_optimization : MetricOptimization | Nonevar model_configvar name : strvar outcome_measurement : OutcomeMeasurement | Nonevar placements : list[Placement] | Nonevar pricing_options : list[PricingOption]var product_card : ProductCard | Nonevar product_card_detailed : ProductCardDetailed | Nonevar product_id : strvar property_targeting_allowed : bool | Nonevar publisher_properties : list[PublisherPropertySelector]var reporting_capabilities : ReportingCapabilities | Nonevar signal_targeting_allowed : bool | Nonevar trusted_match : TrustedMatch | None
Inherited members
class ProductCard (**data: Any)-
Expand source code
class ProductCard(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) format_id: Annotated[ format_id_1.FormatId, Field( description='Creative format defining the card layout (typically product_card_standard)' ), ] manifest: Annotated[ dict[str, Any], Field(description='Asset manifest for rendering the card, structure defined by the format'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var format_id : FormatIdvar manifest : dict[str, typing.Any]var model_config
Inherited members
class ProductCardDetailed (**data: Any)-
Expand source code
class ProductCardDetailed(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) format_id: Annotated[ format_id_1.FormatId, Field( description='Creative format defining the detailed card layout (typically product_card_detailed)' ), ] manifest: Annotated[ dict[str, Any], Field( description='Asset manifest for rendering the detailed card, structure defined by the format' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var format_id : FormatIdvar manifest : dict[str, typing.Any]var model_config
Inherited members
class ProductCatalog (**data: Any)-
Expand source code
class ProductCatalog(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) agentic_checkout: Annotated[ AgenticCheckout | None, Field(description='Agentic checkout endpoint configuration') ] = None categories: Annotated[ list[str] | None, Field(description='Product categories available in the catalog') ] = None feed_format: Annotated[FeedFormat | None, Field(description='Format of the product feed')] = ( None ) feed_url: Annotated[AnyUrl, Field(description='URL to product catalog feed')] last_updated: Annotated[ AwareDatetime | None, Field(description='When the product catalog was last updated') ] = None update_frequency: Annotated[ UpdateFrequency | None, Field(description='How frequently the product catalog is updated') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var agentic_checkout : AgenticCheckout | Nonevar categories : list[str] | Nonevar feed_format : FeedFormat | Nonevar feed_url : pydantic.networks.AnyUrlvar last_updated : pydantic.types.AwareDatetime | Nonevar model_configvar update_frequency : UpdateFrequency | None
Inherited members
class ProductFilters (**data: Any)-
Expand source code
class ProductFilters(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) budget_range: Annotated[ BudgetRange | BudgetRange1 | None, Field(description='Budget range to filter appropriate products'), ] = None channels: Annotated[ list[channels_1.MediaChannel] | None, Field( description="Filter by advertising channels (e.g., ['display', 'ctv', 'dooh'])", min_length=1, ), ] = None countries: Annotated[ list[Country] | None, Field( description="Filter by country coverage using ISO 3166-1 alpha-2 codes (e.g., ['US', 'CA', 'GB']). Works for all inventory types.", min_length=1, ), ] = None delivery_type: delivery_type_1.DeliveryType | None = None end_date: Annotated[ date_aliased | None, Field( description='Campaign end date (ISO 8601 date format: YYYY-MM-DD) for availability checks' ), ] = None exclusivity: Annotated[ exclusivity_1.Exclusivity | None, Field( description="Filter by exclusivity level. Returns products matching the specified exclusivity (e.g., 'exclusive' returns only sole-sponsorship products)." ), ] = None format_ids: Annotated[ list[format_id.FormatId] | None, Field(description='Filter by specific format IDs', min_length=1), ] = None geo_proximity: Annotated[ list[GeoProximity | GeoProximity2 | GeoProximity3] | None, Field( description='Filter by proximity to geographic points. Returns products with inventory coverage near these locations. Follows the same format as the targeting overlay — each entry uses exactly one method: travel_time + transport_mode, radius, or geometry. For locally-bound inventory (DOOH, radio), filters to products with coverage in the area. For digital inventory, filters to products from sellers supporting geo_proximity targeting.', min_length=1, ), ] = None is_fixed_price: Annotated[ bool | None, Field( description='Filter by pricing availability: true = products offering fixed pricing (at least one option with fixed_price), false = products offering auction pricing (at least one option without fixed_price). Products with both fixed and auction options match both true and false.' ), ] = None keywords: Annotated[ list[Keyword] | None, Field( description='Filter by keyword relevance for search and retail media platforms. Returns products that support keyword targeting for these terms. Allows the sell-side agent to assess keyword availability and recommend appropriate products. Use match_type to indicate the desired precision.', min_length=1, ), ] = None metros: Annotated[ list[Metro] | None, Field( description='Filter by metro coverage for locally-bound inventory (radio, DOOH, local TV). Use when products have DMA/metro-specific coverage. For digital inventory where products have broad coverage, use required_geo_targeting instead to filter by seller capability.', min_length=1, ), ] = None min_exposures: Annotated[ int | None, Field(description='Minimum exposures/impressions needed for measurement validity', ge=1), ] = None postal_areas: Annotated[ list[PostalArea] | None, Field( description='Filter by postal area coverage for locally-bound inventory (direct mail, DOOH, local campaigns). Use when products have postal-area-specific coverage. For digital inventory where products have broad coverage, use required_geo_targeting instead to filter by seller capability.', min_length=1, ), ] = None regions: Annotated[ list[Region] | None, Field( description="Filter by region coverage using ISO 3166-2 codes (e.g., ['US-NY', 'US-CA', 'GB-SCT']). Use for locally-bound inventory (regional OOH, local TV) where products have region-specific coverage.", min_length=1, ), ] = None required_axe_integrations: Annotated[ list[AnyUrl] | None, Field( deprecated=True, description='Deprecated: Use trusted_match filter instead. Filter to products executable through specific agentic ad exchanges. URLs are canonical identifiers.', ), ] = None required_features: Annotated[ media_buy_features.MediaBuyFeatures | None, Field( description='Filter to products from sellers supporting specific protocol features. Only features set to true are used for filtering.' ), ] = None required_geo_targeting: Annotated[ list[RequiredGeoTargetingItem] | None, Field( description='Filter to products from sellers supporting specific geo targeting capabilities. Each entry specifies a targeting level (country, region, metro, postal_area) and optionally a system for levels that have multiple classification systems.', min_length=1, ), ] = None signal_targeting: Annotated[ list[signal_targeting_1.SignalTargeting] | None, Field( description='Filter to products supporting specific signals from data provider catalogs. Products must have the requested signals in their data_provider_signals and signal_targeting_allowed must be true (or all signals requested).', min_length=1, ), ] = None standard_formats_only: Annotated[ bool | None, Field(description='Only return products accepting IAB standard formats') ] = None start_date: Annotated[ date_aliased | None, Field( description='Campaign start date (ISO 8601 date format: YYYY-MM-DD) for availability checks' ), ] = None trusted_match: Annotated[ TrustedMatch | None, Field( description='Filter products by Trusted Match Protocol capabilities. Only products with matching TMP support are returned.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var budget_range : BudgetRange | BudgetRange1 | Nonevar channels : list[MediaChannel] | Nonevar countries : list[Country] | Nonevar delivery_type : DeliveryType | Nonevar end_date : datetime.date | Nonevar exclusivity : Exclusivity | Nonevar format_ids : list[FormatId] | Nonevar geo_proximity : list[GeoProximity | GeoProximity2 | GeoProximity3] | Nonevar is_fixed_price : bool | Nonevar keywords : list[Keyword] | Nonevar metros : list[Metro] | Nonevar min_exposures : int | Nonevar model_configvar postal_areas : list[PostalArea] | Nonevar regions : list[Region] | Nonevar required_features : MediaBuyFeatures | Nonevar required_geo_targeting : list[RequiredGeoTargetingItem] | Nonevar signal_targeting : list[SignalTargeting] | Nonevar standard_formats_only : bool | Nonevar start_date : datetime.date | Nonevar trusted_match : TrustedMatch | None
Instance variables
var required_axe_integrations : list[pydantic.networks.AnyUrl] | None-
Expand source code
def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any: if obj is None: if self.wrapped_property is not None: return self.wrapped_property.__get__(None, obj_type) raise AttributeError(self.field_name) warnings.warn(self.msg, DeprecationWarning, stacklevel=2) if self.wrapped_property is not None: return self.wrapped_property.__get__(obj, obj_type) return obj.__dict__[self.field_name]Read-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field.
Attributes
msg- The deprecation message to be emitted.
wrapped_property- The property instance if the deprecated field is a computed field, or
None. field_name- The name of the field being deprecated.
Inherited members
class Property (**data: Any)-
Expand source code
class Property(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) identifiers: Annotated[ list[Identifier], Field(description='Array of identifiers for this property', min_length=1) ] name: Annotated[str, Field(description='Human-readable property name')] property_id: Annotated[ property_id_1.PropertyId | None, Field( description='Unique identifier for this property (optional). Enables referencing properties by ID instead of repeating full objects.' ), ] = None property_type: Annotated[ property_type_1.PropertyType, Field(description='Type of advertising property') ] publisher_domain: Annotated[ str | None, Field( description='Domain where adagents.json should be checked for authorization validation. Optional in adagents.json (file location implies domain).' ), ] = None supported_channels: Annotated[ list[channels.MediaChannel] | None, Field( description="Advertising channels this property supports (e.g., ['display', 'olv', 'social']). Publishers declare which channels their inventory aligns with. Properties may support multiple channels. See the Media Channel Taxonomy for definitions." ), ] = None tags: Annotated[ list[property_tag.PropertyTag] | None, Field( description='Tags for categorization and grouping (e.g., network membership, content categories)' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var identifiers : list[Identifier]var model_configvar name : strvar property_id : PropertyId | Nonevar property_type : PropertyTypevar publisher_domain : str | Nonevar supported_channels : list[MediaChannel] | None
Inherited members
class PropertyId (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class PropertyId(RootModel[str]): root: Annotated[ str, Field( description='Identifier for a publisher property. Must be lowercase alphanumeric with underscores only.', examples=['cnn_ctv_app', 'homepage', 'mobile_ios', 'instagram'], pattern='^[a-z0-9_]+$', title='Property ID', ), ]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : str
class PropertyIdentifierTypes (*args, **kwds)-
Expand source code
class PropertyIdentifierTypes(Enum): domain = 'domain' subdomain = 'subdomain' network_id = 'network_id' ios_bundle = 'ios_bundle' android_package = 'android_package' apple_app_store_id = 'apple_app_store_id' google_play_id = 'google_play_id' roku_store_id = 'roku_store_id' fire_tv_asin = 'fire_tv_asin' samsung_app_id = 'samsung_app_id' apple_tv_bundle = 'apple_tv_bundle' bundle_id = 'bundle_id' venue_id = 'venue_id' screen_id = 'screen_id' openooh_venue_type = 'openooh_venue_type' rss_url = 'rss_url' apple_podcast_id = 'apple_podcast_id' spotify_collection_id = 'spotify_collection_id' podcast_guid = 'podcast_guid'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var android_packagevar apple_app_store_idvar apple_podcast_idvar apple_tv_bundlevar bundle_idvar domainvar fire_tv_asinvar google_play_idvar ios_bundlevar network_idvar openooh_venue_typevar podcast_guidvar roku_store_idvar rss_urlvar samsung_app_idvar screen_idvar spotify_collection_idvar subdomainvar venue_id
class PropertyList (**data: Any)-
Expand source code
class PropertyList(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) base_properties: Annotated[ list[base_property_source.BasePropertySource] | None, Field( description="Array of property sources to evaluate. Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers). If omitted, queries the agent's entire property database." ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference used to automatically apply appropriate rules. Resolved to full brand identity at execution time.' ), ] = None cache_duration_hours: Annotated[ int | None, Field( description='Recommended cache duration for resolved list. Consumers should re-fetch after this period.', ge=1, ), ] = 24 created_at: Annotated[AwareDatetime | None, Field(description='When the list was created')] = ( None ) description: Annotated[str | None, Field(description="Description of the list's purpose")] = ( None ) filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Dynamic filters applied when resolving the list'), ] = None list_id: Annotated[str, Field(description='Unique identifier for this property list')] name: Annotated[str, Field(description='Human-readable name for the list')] principal: Annotated[ str | None, Field(description='Principal identity that owns this list') ] = None property_count: Annotated[ int | None, Field(description='Number of properties in the resolved list (at time of last resolution)'), ] = None updated_at: Annotated[ AwareDatetime | None, Field(description='When the list was last modified') ] = None webhook_url: Annotated[ AnyUrl | None, Field(description='URL to receive notifications when the resolved list changes'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var base_properties : list[BasePropertySource] | Nonevar brand : BrandReference | Nonevar cache_duration_hours : int | Nonevar created_at : pydantic.types.AwareDatetime | Nonevar description : str | Nonevar filters : PropertyListFilters | Nonevar list_id : strvar model_configvar name : strvar principal : str | Nonevar property_count : int | Nonevar updated_at : pydantic.types.AwareDatetime | Nonevar webhook_url : pydantic.networks.AnyUrl | None
Inherited members
class PropertyListChangedWebhook (**data: Any)-
Expand source code
class PropertyListChangedWebhook(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) cache_valid_until: Annotated[ AwareDatetime | None, Field(description='When the consumer should refresh from the governance agent'), ] = None change_summary: Annotated[ ChangeSummary | None, Field(description='Summary of changes to the resolved list') ] = None event: Annotated[Literal['property_list_changed'], Field(description='The event type')] ext: ext_1.ExtensionObject | None = None list_id: Annotated[str, Field(description='ID of the property list that changed')] list_name: Annotated[str | None, Field(description='Name of the property list')] = None resolved_at: Annotated[AwareDatetime, Field(description='When the list was re-resolved')] signature: Annotated[ str, Field( description="Cryptographic signature of the webhook payload, signed with the agent's private key. Recipients MUST verify this signature." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var cache_valid_until : pydantic.types.AwareDatetime | Nonevar change_summary : ChangeSummary | Nonevar event : Literal['property_list_changed']var ext : ExtensionObject | Nonevar list_id : strvar list_name : str | Nonevar model_configvar resolved_at : pydantic.types.AwareDatetimevar signature : str
Inherited members
class PropertyListFilters (**data: Any)-
Expand source code
class PropertyListFilters(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) channels_any: Annotated[ list[channels.MediaChannel] | None, Field( description='Property must support ANY of the listed channels. When omitted, no channel restriction is applied.', min_length=1, ), ] = None countries_all: Annotated[ list[CountriesAllItem] | None, Field( description='Property must have feature data for ALL listed countries (ISO codes). When omitted, no country restriction is applied.', min_length=1, ), ] = None exclude_identifiers: Annotated[ list[identifier.Identifier] | None, Field(description='Identifiers to always exclude from results', min_length=1), ] = None feature_requirements: Annotated[ list[feature_requirement.FeatureRequirement] | None, Field( description='Feature-based requirements. Property must pass ALL requirements (AND logic).', min_length=1, ), ] = None property_types: Annotated[ list[property_type.PropertyType] | None, Field(description='Filter to these property types', min_length=1), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var channels_any : list[MediaChannel] | Nonevar countries_all : list[CountriesAllItem] | Nonevar exclude_identifiers : list[Identifier] | Nonevar feature_requirements : list[FeatureRequirement] | Nonevar model_configvar property_types : list[PropertyType] | None
Inherited members
class PropertyListReference (**data: Any)-
Expand source code
class PropertyListReference(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) agent_url: Annotated[AnyUrl, Field(description='URL of the agent managing the property list')] auth_token: Annotated[ str | None, Field( description='JWT or other authorization token for accessing the list. Optional if the list is public or caller has implicit access.' ), ] = None list_id: Annotated[ str, Field(description='Identifier for the property list within the agent', min_length=1) ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var agent_url : pydantic.networks.AnyUrlvar auth_token : str | Nonevar list_id : strvar model_config
Inherited members
class PropertyTag (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class PropertyTag(RootModel[str]): root: Annotated[ str, Field( description='Tag for categorizing publisher properties. Must be lowercase alphanumeric with underscores only.', examples=['ctv', 'premium', 'news', 'sports', 'meta_network', 'social_media'], pattern='^[a-z0-9_]+$', title='Property Tag', ), ]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : str
class PropertyType (*args, **kwds)-
Expand source code
class PropertyType(Enum): website = 'website' mobile_app = 'mobile_app' ctv_app = 'ctv_app' desktop_app = 'desktop_app' dooh = 'dooh' podcast = 'podcast' radio = 'radio' streaming_audio = 'streaming_audio' ai_assistant = 'ai_assistant'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var ai_assistantvar ctv_appvar desktop_appvar doohvar mobile_appvar podcastvar radiovar streaming_audiovar website
class Proposal (**data: Any)-
Expand source code
class Proposal(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) allocations: Annotated[ list[product_allocation.ProductAllocation], Field( description='Budget allocations across products. Allocation percentages MUST sum to 100. Publishers are responsible for ensuring the sum equals 100; buyers SHOULD validate this before execution.', min_length=1, ), ] brief_alignment: Annotated[ str | None, Field( description='Explanation of how this proposal aligns with the campaign brief', max_length=2000, ), ] = None description: Annotated[ str | None, Field( description='Explanation of the proposal strategy and what it achieves', max_length=2000 ), ] = None expires_at: Annotated[ AwareDatetime | None, Field( description='When this proposal expires and can no longer be executed. For draft proposals, indicates when indicative pricing becomes stale. For committed proposals, indicates when the inventory hold lapses — the buyer must call create_media_buy before this time.' ), ] = None ext: ext_1.ExtensionObject | None = None forecast: Annotated[ delivery_forecast.DeliveryForecast | None, Field( description='Aggregate forecasted delivery metrics for the entire proposal. When both proposal-level and allocation-level forecasts are present, the proposal-level forecast is authoritative for total delivery estimation.' ), ] = None insertion_order: Annotated[ insertion_order_1.InsertionOrder | None, Field( description='Formal insertion order attached to a committed proposal. Present when the seller requires a signed agreement before the media buy can proceed. The buyer references the io_id in io_acceptance on create_media_buy.' ), ] = None name: Annotated[ str, Field(description='Human-readable name for this media plan proposal', max_length=500) ] proposal_id: Annotated[ str, Field( description='Unique identifier for this proposal. Used to execute it via create_media_buy.', max_length=255, ), ] proposal_status: Annotated[ proposal_status_1.ProposalStatus | None, Field( description="Lifecycle status of this proposal. When absent, the proposal is ready to buy (backward compatible). 'draft' means indicative pricing — finalize via refine before purchasing. 'committed' means firm pricing with inventory reserved until expires_at." ), ] = None total_budget_guidance: Annotated[ TotalBudgetGuidance | None, Field(description='Optional budget guidance for this proposal') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var allocations : list[ProductAllocation]var brief_alignment : str | Nonevar description : str | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar forecast : DeliveryForecast | Nonevar insertion_order : InsertionOrder | Nonevar model_configvar name : strvar proposal_id : strvar proposal_status : ProposalStatus | Nonevar total_budget_guidance : TotalBudgetGuidance | None
Inherited members
class Protocol (*args, **kwds)-
Expand source code
class Protocol(str, Enum): """Supported protocols.""" A2A = "a2a" MCP = "mcp"Supported protocols.
Ancestors
- builtins.str
- enum.Enum
Class variables
var A2Avar MCP
class ProtocolEnvelope (**data: Any)-
Expand source code
class ProtocolEnvelope(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context_id: Annotated[ str | None, Field( description='Session/conversation identifier for tracking related operations across multiple task invocations. Managed by the protocol layer to maintain conversational context.' ), ] = None governance_context: Annotated[ str | None, Field( description="Opaque governance context issued by a governance agent during check_governance. Buyers attach it to media buy requests; sellers persist it and include it on all subsequent governance calls for that media buy's lifecycle. Neither buyers nor sellers interpret this value — only the governance agent that issued it.", max_length=4096, min_length=1, pattern='^[\\x20-\\x7E]+$', ), ] = None message: Annotated[ str | None, Field( description='Human-readable summary of the task result. Provides natural language explanation of what happened, suitable for display to end users or for AI agent comprehension. Generated by the protocol layer based on the task response.' ), ] = None payload: Annotated[ dict[str, Any], Field( description='The actual task-specific response data. This is the content defined in individual task response schemas (e.g., get-products-response.json, create-media-buy-response.json). Contains only domain-specific data without protocol-level fields.' ), ] push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Push notification configuration for async task updates (A2A and REST protocols). Echoed from the request to confirm webhook settings. Specifies URL, authentication scheme (Bearer or HMAC-SHA256), and credentials. MCP uses progress notifications instead of webhooks.' ), ] = None status: Annotated[ task_status.TaskStatus, Field( description='Current task execution state. Indicates whether the task is completed, in progress (working), submitted for async processing, failed, or requires user input. Managed by the protocol layer.' ), ] task_id: Annotated[ str | None, Field( description='Unique identifier for tracking asynchronous operations. Present when a task requires extended processing time. Used to query task status and retrieve results when complete.' ), ] = None timestamp: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when the response was generated. Useful for debugging, logging, cache validation, and tracking async operation progress.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context_id : str | Nonevar governance_context : str | Nonevar message : str | Nonevar model_configvar payload : dict[str, typing.Any]var push_notification_config : PushNotificationConfig | Nonevar status : TaskStatusvar task_id : str | Nonevar timestamp : pydantic.types.AwareDatetime | None
Inherited members
class ProtocolResponse (**data: Any)-
Expand source code
class ProtocolResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context_id: Annotated[str | None, Field(description='Session continuity identifier')] = None data: Annotated[ Any | None, Field( description='AdCP task-specific response data (see individual task response schemas)' ), ] = None message: Annotated[str, Field(description='Human-readable summary')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context_id : str | Nonevar data : typing.Any | Nonevar message : strvar model_config
Inherited members
class ProvidePerformanceFeedbackRequest (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None ext: ext_1.ExtensionObject | None = None feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate feedback submissions on 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, ), ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] media_buy_id: Annotated[str, Field(description="Seller's media buy identifier", min_length=1)] metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar idempotency_key : str | Nonevar measurement_period : DatetimeRangevar media_buy_id : strvar metric_type : MetricType | Nonevar model_configvar package_id : str | Nonevar performance_index : float
class ProvidePerformanceFeedbackByBuyerRefRequest (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None ext: ext_1.ExtensionObject | None = None feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate feedback submissions on 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, ), ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] media_buy_id: Annotated[str, Field(description="Seller's media buy identifier", min_length=1)] metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar idempotency_key : str | Nonevar measurement_period : DatetimeRangevar media_buy_id : strvar metric_type : MetricType | Nonevar model_configvar package_id : str | Nonevar performance_index : float
class ProvidePerformanceFeedbackByMediaBuyRequest (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None ext: ext_1.ExtensionObject | None = None feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate feedback submissions on 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, ), ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] media_buy_id: Annotated[str, Field(description="Seller's media buy identifier", min_length=1)] metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar idempotency_key : str | Nonevar measurement_period : DatetimeRangevar media_buy_id : strvar metric_type : MetricType | Nonevar model_configvar package_id : str | Nonevar performance_index : float
Inherited members
class ProvidePerformanceFeedbackSuccessResponse (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None success: Annotated[ Literal[True], Field(description='Whether the performance feedback was successfully received'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar sandbox : bool | Nonevar success : Literal[True]
Inherited members
class ProvidePerformanceFeedbackErrorResponse (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field( description='Array of errors explaining why feedback was rejected (e.g., invalid measurement period, missing campaign data)', min_length=1, ), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class PublisherDomain (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class PublisherDomain(RootModel[str]): root: Annotated[ str, Field(pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$') ]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[str]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Subclasses
Class variables
var model_configvar root : str
class PublisherIdentifierTypes (*args, **kwds)-
Expand source code
class PublisherIdentifierTypes(Enum): tag_id = 'tag_id' duns = 'duns' lei = 'lei' seller_id = 'seller_id' gln = 'gln'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dunsvar glnvar leivar seller_idvar tag_id
class PublisherPropertiesAll (**data: Any)-
Expand source code
class PublisherPropertySelector1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) publisher_domain: Annotated[ str, Field( description="Domain where publisher's adagents.json is hosted (e.g., 'cnn.com')", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] selection_type: Annotated[ Literal['all'], Field( description='Discriminator indicating all properties from this publisher are included' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar publisher_domain : strvar selection_type : Literal['all']
Inherited members
class PublisherPropertiesById (**data: Any)-
Expand source code
class PublisherPropertySelector2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) property_ids: Annotated[ list[property_id.PropertyId], Field(description="Specific property IDs from the publisher's adagents.json", min_length=1), ] publisher_domain: Annotated[ str, Field( description="Domain where publisher's adagents.json is hosted (e.g., 'cnn.com')", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] selection_type: Annotated[ Literal['by_id'], Field(description='Discriminator indicating selection by specific property IDs'), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar property_ids : list[PropertyId]var publisher_domain : strvar selection_type : Literal['by_id']
Inherited members
class PublisherPropertiesByTag (**data: Any)-
Expand source code
class PublisherPropertySelector3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) property_tags: Annotated[ list[property_tag.PropertyTag], Field( description="Property tags from the publisher's adagents.json. Selector covers all properties with these tags", min_length=1, ), ] publisher_domain: Annotated[ str, Field( description="Domain where publisher's adagents.json is hosted (e.g., 'cnn.com')", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] selection_type: Annotated[ Literal['by_tag'], Field(description='Discriminator indicating selection by property tags') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar publisher_domain : strvar selection_type : Literal['by_tag']
Inherited members
class PushNotificationConfig (**data: Any)-
Expand source code
class PushNotificationConfig(AdCPBaseModel): authentication: Annotated[ Authentication, Field(description='Authentication configuration for webhook delivery (A2A-compatible)'), ] token: Annotated[ str | None, Field( description='Optional client-provided token for webhook validation. Echoed back in webhook payload to validate request authenticity.', min_length=16, ), ] = None url: Annotated[AnyUrl, Field(description='Webhook endpoint URL for task status notifications')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var authentication : Authenticationvar model_configvar token : str | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class QuartileData (**data: Any)-
Expand source code
class QuartileData(AdCPBaseModel): q1_views: Annotated[float | None, Field(description='25% completion views', ge=0.0)] = None q2_views: Annotated[float | None, Field(description='50% completion views', ge=0.0)] = None q3_views: Annotated[float | None, Field(description='75% completion views', ge=0.0)] = None q4_views: Annotated[float | None, Field(description='100% completion views', ge=0.0)] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar q1_views : float | Nonevar q2_views : float | Nonevar q3_views : float | Nonevar q4_views : float | None
Inherited members
class QuerySummary (**data: Any)-
Expand source code
class QuerySummary(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) filters_applied: Annotated[ list[str] | None, Field(description='List of filters that were applied to the query') ] = None returned: Annotated[ int, Field(description='Number of creatives returned in this response', ge=0) ] sort_applied: Annotated[ SortApplied | None, Field(description='Sort order that was applied') ] = None total_matching: Annotated[ int, Field(description='Total number of creatives matching filters (across all pages)', ge=0), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var filters_applied : list[str] | Nonevar model_configvar returned : intvar sort_applied : SortApplied | Nonevar total_matching : int
Inherited members
class ReachUnit (*args, **kwds)-
Expand source code
class ReachUnit(Enum): individuals = 'individuals' households = 'households' devices = 'devices' accounts = 'accounts' cookies = 'cookies' custom = 'custom'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var accountsvar customvar devicesvar householdsvar individuals
class Refine (**data: Any)-
Expand source code
class Refine(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) ask: Annotated[ str, Field( description="What the buyer is asking for at the request level (e.g., 'more video options and less display', 'suggest how to combine these products').", min_length=1, ), ] scope: Annotated[ Literal['request'], Field( description='Change scoped to the overall request — direction for the selection as a whole.' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var ask : strvar model_configvar scope : Literal['request']
Inherited members
class ReportPlanOutcomeRequest (**data: Any)-
Expand source code
class ReportPlanOutcomeRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) check_id: Annotated[ str | None, Field( description="The check_id from check_governance. Links the outcome to the governance check that authorized it. Required for 'completed' and 'failed' outcomes." ), ] = None delivery: Annotated[ Delivery | None, Field(description="Delivery metrics. Required when outcome is 'delivery'.") ] = None error: Annotated[ Error | None, Field(description="Error details. Required when outcome is 'failed'.") ] = None governance_context: Annotated[ str, Field( description='Opaque governance context from the check_governance response that authorized this action. Enables the governance agent to correlate the outcome to the original check.', max_length=4096, min_length=1, pattern='^[\\x20-\\x7E]+$', ), ] idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate outcome reports on 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, ), ] = None outcome: Annotated[outcome_type.OutcomeType, Field(description='Outcome type.')] plan_id: Annotated[str, Field(description='The plan this outcome is for.')] seller_response: Annotated[ SellerResponse | None, Field(description="The seller's full response. Required when outcome is 'completed'."), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var check_id : str | Nonevar delivery : Delivery | Nonevar error : Error | Nonevar governance_context : strvar idempotency_key : str | Nonevar model_configvar outcome : OutcomeTypevar plan_id : strvar seller_response : SellerResponse | None
Inherited members
class ReportPlanOutcomeResponse (**data: Any)-
Expand source code
class ReportPlanOutcomeResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) committed_budget: Annotated[ float | None, Field( description="Budget committed from this outcome. Present for 'completed' and 'failed' outcomes." ), ] = None findings: Annotated[ list[Finding] | None, Field(description="Issues detected. Present only when status is 'findings'."), ] = None outcome_id: Annotated[str, Field(description='Unique identifier for this outcome record.')] plan_summary: Annotated[ PlanSummary | None, Field( description="Updated plan budget state. Present for 'completed' and 'failed' outcomes." ), ] = None status: Annotated[ Status, Field( description="'accepted' means state updated with no issues. 'findings' means issues were detected." ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var committed_budget : float | Nonevar findings : list[Finding] | Nonevar model_configvar outcome_id : strvar plan_summary : PlanSummary | Nonevar status : Status
Inherited members
class ReportUsageRequest (**data: Any)-
Expand source code
class ReportUsageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. If a request with the same key has already been accepted, the server returns the original response without re-processing. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request. Prevents duplicate billing on retries.' ), ] = None reporting_period: Annotated[ datetime_range.DatetimeRange, Field( description='The time range covered by this usage report. Applies to all records in the request.' ), ] usage: Annotated[ list[UsageItem], Field( description='One or more usage records. Each record is self-contained: it carries its own account, allowing a single request to span multiple accounts.', min_length=1, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar reporting_period : DatetimeRangevar usage : list[UsageItem]
Inherited members
class ReportUsageResponse (**data: Any)-
Expand source code
class ReportUsageResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accepted: Annotated[ int, Field(description='Number of usage records successfully stored.', ge=0) ] context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error] | None, Field( description="Validation errors for individual records. The field property identifies which record failed (e.g., 'usage[1].pricing_option_id')." ), ] = None ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, the account is a sandbox account and no billing occurred.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accepted : intvar context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class ReportingCapabilities (**data: Any)-
Expand source code
class ReportingCapabilities(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) available_metrics: Annotated[ list[available_metric.AvailableMetric], Field( description="Metrics available in reporting. Impressions and spend are always implicitly included. When a creative format declares reported_metrics, buyers receive the intersection of these product-level metrics and the format's reported_metrics.", examples=[ ['impressions', 'spend', 'clicks', 'video_completions'], ['impressions', 'spend', 'conversions'], ], ), ] available_reporting_frequencies: Annotated[ list[reporting_frequency.ReportingFrequency], Field(description='Supported reporting frequency options', min_length=1), ] date_range_support: Annotated[ DateRangeSupport, Field( description="Whether delivery data can be filtered to arbitrary date ranges. 'date_range' means the platform supports start_date/end_date parameters. 'lifetime_only' means the platform returns campaign lifetime totals and date range parameters are not accepted." ), ] expected_delay_minutes: Annotated[ int, Field( description='Expected delay in minutes before reporting data becomes available (e.g., 240 for 4-hour delay)', examples=[240, 300, 1440], ge=0, ), ] supports_audience_breakdown: Annotated[ bool | None, Field( description='Whether this product supports audience segment breakdowns in delivery reporting (by_audience within by_package)' ), ] = None supports_creative_breakdown: Annotated[ bool | None, Field( description='Whether this product supports creative-level metric breakdowns in delivery reporting (by_creative within by_package)' ), ] = None supports_device_platform_breakdown: Annotated[ bool | None, Field( description='Whether this product supports device platform breakdowns in delivery reporting (by_device_platform within by_package)' ), ] = None supports_device_type_breakdown: Annotated[ bool | None, Field( description='Whether this product supports device type breakdowns in delivery reporting (by_device_type within by_package)' ), ] = None supports_geo_breakdown: Annotated[ geo_breakdown_support.GeographicBreakdownSupport | None, Field( description='Geographic breakdown support for this product. Declares which geo levels and systems are available for by_geo reporting within by_package.' ), ] = None supports_keyword_breakdown: Annotated[ bool | None, Field( description='Whether this product supports keyword-level metric breakdowns in delivery reporting (by_keyword within by_package)' ), ] = None supports_placement_breakdown: Annotated[ bool | None, Field( description='Whether this product supports placement breakdowns in delivery reporting (by_placement within by_package)' ), ] = None supports_webhooks: Annotated[ bool, Field(description='Whether this product supports webhook-based reporting notifications'), ] timezone: Annotated[ str, Field( description="Timezone for reporting periods. Use 'UTC' or IANA timezone (e.g., 'America/New_York'). Critical for daily/monthly frequency alignment.", examples=['UTC', 'America/New_York', 'Europe/London', 'America/Los_Angeles'], ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var available_metrics : list[AvailableMetric]var available_reporting_frequencies : list[ReportingFrequency]var date_range_support : DateRangeSupportvar expected_delay_minutes : intvar model_configvar supports_audience_breakdown : bool | Nonevar supports_creative_breakdown : bool | Nonevar supports_device_platform_breakdown : bool | Nonevar supports_device_type_breakdown : bool | Nonevar supports_geo_breakdown : GeographicBreakdownSupport | Nonevar supports_keyword_breakdown : bool | Nonevar supports_placement_breakdown : bool | Nonevar supports_webhooks : boolvar timezone : str
Inherited members
class ReportingFrequency (*args, **kwds)-
Expand source code
class ReportingFrequency(Enum): hourly = 'hourly' daily = 'daily' monthly = 'monthly'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dailyvar hourlyvar monthly
class AvailableReportingFrequency (*args, **kwds)-
Expand source code
class ReportingFrequency(Enum): hourly = 'hourly' daily = 'daily' monthly = 'monthly'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dailyvar hourlyvar monthly
class ReportingPeriod (**data: Any)-
Expand source code
class ReportingPeriod(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) end: Annotated[AwareDatetime, Field(description='ISO 8601 end timestamp')] start: Annotated[AwareDatetime, Field(description='ISO 8601 start timestamp')] timezone: Annotated[ str | None, Field( description="IANA timezone identifier for the reporting period (e.g., 'America/New_York', 'UTC'). Platforms report in their native timezone." ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var end : pydantic.types.AwareDatetimevar model_configvar start : pydantic.types.AwareDatetimevar timezone : str | None
Inherited members
class ReportingWebhook (**data: Any)-
Expand source code
class ReportingWebhook(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) authentication: Annotated[ Authentication, Field(description='Authentication configuration for webhook delivery (A2A-compatible)'), ] reporting_frequency: Annotated[ ReportingFrequency, Field( description='Frequency for automated reporting delivery. Must be supported by all products in the media buy.' ), ] requested_metrics: Annotated[ list[available_metric.AvailableMetric] | None, Field( description="Optional list of metrics to include in webhook notifications. If omitted, all available metrics are included. Must be subset of product's available_metrics." ), ] = None token: Annotated[ str | None, Field( description='Optional client-provided token for webhook validation. Echoed back in webhook payload to validate request authenticity.', min_length=16, ), ] = None url: Annotated[AnyUrl, Field(description='Webhook endpoint URL for reporting notifications')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var authentication : Authenticationvar model_configvar reporting_frequency : ReportingFrequencyvar requested_metrics : list[AvailableMetric] | Nonevar token : str | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class Request (**data: Any)-
Expand source code
class Request(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets.'), ] format_id: Annotated[ format_id_1.FormatId | None, Field( description='Format identifier for rendering the preview. Optional — defaults to creative_manifest_1.format_id if omitted.' ), ] = None inputs: Annotated[ list[Input4] | None, Field( description='Array of input sets for generating multiple preview variants', min_length=1 ), ] = None item_limit: Annotated[ int | None, Field(description='Maximum number of catalog items to render in this preview.', ge=1), ] = None output_format: Annotated[ preview_output_format.PreviewOutputFormat | None, Field( description="Output format for this preview. 'url' returns preview_url, 'html' returns preview_html." ), ] = preview_output_format.PreviewOutputFormat.url quality: Annotated[ creative_quality.CreativeQuality | None, Field( description="Render quality for this preview. 'draft' produces fast, lower-fidelity renderings. 'production' produces full-quality renderings. Overrides any batch-level default." ), ] = None template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var creative_manifest : CreativeManifestvar format_id : FormatId | Nonevar inputs : list[Input4] | Nonevar item_limit : int | Nonevar model_configvar output_format : PreviewOutputFormat | Nonevar quality : CreativeQuality | Nonevar template_id : str | None
Inherited members
class ResolvedBrand (**data: Any)-
Expand source code
class ResolvedBrand(BaseModel): """Brand identity resolved from the AdCP registry.""" model_config = ConfigDict(extra="allow") canonical_id: str canonical_domain: str brand_name: str names: list[dict[str, str]] | None = None keller_type: str | None = None parent_brand: str | None = None house_domain: str | None = None house_name: str | None = None brand_agent_url: str | None = None brand: dict[str, Any] | None = None brand_manifest: dict[str, Any] | None = None source: str @model_validator(mode="before") @classmethod def _normalize_brand_fields(cls, data: Any) -> Any: """Cross-populate brand and brand_manifest so both names are always accessible.""" if isinstance(data, dict): data = dict(data) if "brand" in data and "brand_manifest" not in data: data["brand_manifest"] = data["brand"] elif "brand_manifest" in data and "brand" not in data: data["brand"] = data["brand_manifest"] return dataBrand identity resolved from the AdCP 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var brand : dict[str, typing.Any] | Nonevar brand_agent_url : str | Nonevar brand_manifest : dict[str, typing.Any] | Nonevar brand_name : strvar canonical_domain : strvar canonical_id : strvar house_domain : str | Nonevar house_name : str | Nonevar keller_type : str | Nonevar model_configvar names : list[dict[str, str]] | Nonevar parent_brand : str | Nonevar source : str
class ResolvedProperty (**data: Any)-
Expand source code
class ResolvedProperty(BaseModel): """Property information resolved from the AdCP registry.""" model_config = ConfigDict(extra="allow") publisher_domain: str source: str authorized_agents: list[dict[str, Any]] properties: list[dict[str, Any]] verified: boolProperty information resolved from the AdCP 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var model_configvar properties : list[dict[str, typing.Any]]var publisher_domain : strvar source : strvar verified : bool
class Response (**data: Any)-
Expand source code
class Response(AdCPBaseModel): expires_at: Annotated[AwareDatetime, Field(description='When the preview URLs expire')] interactive_url: AnyUrl | None = None previews: Annotated[ list[Preview5], Field(description='Array of preview variants for this creative', min_length=1), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var expires_at : pydantic.types.AwareDatetimevar interactive_url : pydantic.networks.AnyUrl | Nonevar model_configvar previews : list[Preview5]
Inherited members
class Responsive (**data: Any)-
Expand source code
class Responsive(AdCPBaseModel): height: bool width: boolBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var height : boolvar model_configvar width : bool
Inherited members
class Results (**data: Any)-
Expand source code
class Results(AdCPBaseModel): creative_id: Annotated[ str, Field( description='ID of the creative this result corresponds to. Enables correlation when processing batch results.' ), ] errors: Annotated[ list[error.Error] | None, Field(description='Errors for failed requests', min_length=1) ] = None response: Annotated[Response, Field(description='Preview data for successful requests')] success: Annotated[Literal[True], Field(description='Indicates this preview request succeeded')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var creative_id : strvar errors : list[Error] | Nonevar model_configvar response : Responsevar success : Literal[True]
Inherited members
class RightsPricingOption (**data: Any)-
Expand source code
class RightsPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[str, Field(description='ISO 4217 currency code', pattern='^[A-Z]{3}$')] description: Annotated[ str | None, Field(description='Human-readable description of this pricing option') ] = None ext: ext_1.ExtensionObject | None = None impression_cap: Annotated[ int | None, Field(description='Maximum impressions included in this pricing option per period', ge=1), ] = None model: Annotated[ pricing_model.PricingModel, Field(description='Pricing model (cpm, flat_rate, etc.)') ] overage_cpm: Annotated[ float | None, Field(description='CPM rate applied to impressions exceeding the impression_cap', ge=0.0), ] = None period: Annotated[ Period | None, Field(description='Billing period for flat_rate and time-based models') ] = None price: Annotated[ float, Field( description='Price amount. Interpretation depends on model: CPM = cost per 1,000 impressions, flat_rate = fixed cost per period.', ge=0.0, ), ] pricing_option_id: Annotated[ str, Field( description='Unique identifier for this pricing option. Referenced in acquire_rights and report_usage.' ), ] 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, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar description : str | Nonevar ext : ExtensionObject | Nonevar impression_cap : int | Nonevar model : PricingModelvar model_configvar overage_cpm : float | Nonevar period : Period | Nonevar price : floatvar pricing_option_id : strvar uses : list[RightUse]
Inherited members
class RightsTerms (**data: Any)-
Expand source code
class RightsTerms(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) amount: Annotated[float, Field(ge=0.0)] currency: Annotated[str, Field(pattern='^[A-Z]{3}$')] end_date: date_aliased | None = None exclusivity: Annotated[ Exclusivity | None, Field(description='Exclusivity terms if applicable') ] = None impression_cap: Annotated[int | None, Field(ge=1)] = None overage_cpm: Annotated[float | None, Field(ge=0.0)] = None period: Period | None = None pricing_option_id: str start_date: date_aliased | None = None uses: list[right_use.RightUse]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var amount : floatvar currency : strvar end_date : datetime.date | Nonevar exclusivity : Exclusivity | Nonevar impression_cap : int | Nonevar model_configvar overage_cpm : float | Nonevar period : Period | Nonevar pricing_option_id : strvar start_date : datetime.date | Nonevar uses : list[RightUse]
Inherited members
class Security (**data: Any)-
Expand source code
class Security(AdCPBaseModel): api_key_header: Annotated[ str | None, Field(description="Header name for API key (e.g., 'X-API-Key')") ] = None hmac_header: Annotated[ str | None, Field(description="Header name for HMAC signature (e.g., 'X-Signature')") ] = None method: Annotated[ webhook_security_method.WebhookSecurityMethod, Field(description='Authentication method') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var api_key_header : str | Nonevar hmac_header : str | Nonevar method : WebhookSecurityMethodvar model_config
Inherited members
class SiCapabilities (**data: Any)-
Expand source code
class SiCapabilities(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) a2ui: Annotated[A2ui | None, Field(description='A2UI (Agent-to-UI) capabilities')] = None commerce: Annotated[Commerce | None, Field(description='Commerce capabilities')] = None components: Annotated[Components | None, Field(description='Visual components supported')] = ( None ) mcp_apps: Annotated[ bool | None, Field(description='Supports MCP Apps for rendering A2UI surfaces in iframes') ] = False modalities: Annotated[ Modalities | None, Field(description='Interaction modalities supported') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var a2ui : A2ui | Nonevar commerce : Commerce | Nonevar components : Components | Nonevar mcp_apps : bool | Nonevar modalities : Modalities | Nonevar model_config
Inherited members
class SiGetOfferingRequest (**data: Any)-
Expand source code
class SiGetOfferingRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: Annotated[ str | None, Field( description="Optional natural language context about user intent for personalized results (e.g., 'mens size 14 near Cincinnati'). Must be anonymous - no PII." ), ] = None ext: ext_1.ExtensionObject | None = None include_products: Annotated[ bool | None, Field(description='Whether to include matching products in the response') ] = False offering_id: Annotated[ str, Field(description='Offering identifier from the catalog to get details for') ] product_limit: Annotated[ int | None, Field(description='Maximum number of matching products to return', ge=1, le=50) ] = 5Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : str | Nonevar ext : ExtensionObject | Nonevar include_products : bool | Nonevar model_configvar offering_id : strvar product_limit : int | None
Inherited members
class SiGetOfferingResponse (**data: Any)-
Expand source code
class SiGetOfferingResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) alternative_offering_ids: Annotated[ list[str] | None, Field(description='Alternative offerings to consider if this one is unavailable'), ] = None available: Annotated[bool, Field(description='Whether the offering is currently available')] checked_at: Annotated[ AwareDatetime | None, Field(description='When this offering information was retrieved') ] = None errors: Annotated[ list[error.Error] | None, Field(description='Errors during offering lookup') ] = None ext: ext_1.ExtensionObject | None = None matching_products: Annotated[ list[MatchingProduct] | None, Field( description='Products matching the request context. Only included if include_products was true.' ), ] = None offering: Annotated[Offering | None, Field(description='Offering details')] = None offering_token: Annotated[ str | None, Field( description="Token to pass to si_initiate_session for session continuity. Brand stores the full query context server-side (products shown, order, context) so they can resolve references like 'the second one' when the session starts." ), ] = None total_matching: Annotated[ int | None, Field( description='Total number of products matching the context (may be more than returned in matching_products)', ge=0, ), ] = None ttl_seconds: Annotated[ int | None, Field( description='How long this offering information is valid (seconds). Host should re-fetch after TTL expires.', ge=0, ), ] = None unavailable_reason: Annotated[ str | None, Field( description="If not available, why (e.g., 'expired', 'sold_out', 'region_restricted')" ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var alternative_offering_ids : list[str] | Nonevar available : boolvar checked_at : pydantic.types.AwareDatetime | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar matching_products : list[MatchingProduct] | Nonevar model_configvar offering : Offering | Nonevar offering_token : str | Nonevar total_matching : int | Nonevar ttl_seconds : int | None
Inherited members
class SiIdentity (**data: Any)-
Expand source code
class SiIdentity(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) anonymous_session_id: Annotated[ str | None, Field(description='Session ID for anonymous users (when consent_granted is false)'), ] = None consent_granted: Annotated[bool, Field(description='Whether user consented to share identity')] consent_scope: Annotated[ list[ConsentScopeEnum] | None, Field(description='What data was consented to share') ] = None consent_timestamp: Annotated[ AwareDatetime | None, Field(description='When consent was granted (ISO 8601)') ] = None privacy_policy_acknowledged: Annotated[ PrivacyPolicyAcknowledged | None, Field(description='Brand privacy policy acknowledgment') ] = None user: Annotated[ User | None, Field(description='User data (only present if consent_granted is true)') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var anonymous_session_id : str | Nonevar consent_granted : boolvar consent_scope : list[ConsentScopeEnum] | Nonevar consent_timestamp : pydantic.types.AwareDatetime | Nonevar model_configvar privacy_policy_acknowledged : PrivacyPolicyAcknowledged | Nonevar user : User | None
Inherited members
class SiInitiateSessionRequest (**data: Any)-
Expand source code
class SiInitiateSessionRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: Annotated[ str, Field(description='Conversation handoff from the host describing what the user needs') ] ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for this request. Prevents duplicate session creation on 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, ), ] = None identity: si_identity.SiIdentity media_buy_id: Annotated[ str | None, Field(description='AdCP media buy ID if session was triggered by advertising') ] = None offering_id: Annotated[ str | None, Field(description='Brand-specific offering identifier to apply') ] = None offering_token: Annotated[ str | None, Field( description="Token from si_get_offering response for session continuity. Brand uses this to recall what products were shown to the user, enabling natural references like 'the second one' or 'that blue shoe'." ), ] = None placement: Annotated[ str | None, Field( description="Where this session was triggered (e.g., 'chatgpt_search', 'claude_chat')" ), ] = None supported_capabilities: Annotated[ si_capabilities.SiCapabilities | None, Field(description='What capabilities the host supports'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : strvar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar identity : SiIdentityvar media_buy_id : str | Nonevar model_configvar offering_id : str | Nonevar offering_token : str | Nonevar placement : str | Nonevar supported_capabilities : SiCapabilities | None
Inherited members
class SiInitiateSessionResponse (**data: Any)-
Expand source code
class SiInitiateSessionResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) errors: Annotated[ list[error.Error] | None, Field(description='Errors during session initiation') ] = None ext: ext_1.ExtensionObject | None = None negotiated_capabilities: Annotated[ si_capabilities.SiCapabilities | None, Field(description='Intersection of brand and host capabilities for this session'), ] = None response: Annotated[Response | None, Field(description="Brand agent's initial response")] = None session_id: Annotated[ str, Field(description='Unique session identifier for subsequent messages') ] session_status: Annotated[ si_session_status.SiSessionStatus, Field( description='Current session lifecycle state. Returned in initiation, message, and termination responses.' ), ] session_ttl_seconds: Annotated[ int | None, Field( description='Session inactivity timeout in seconds. After this duration without a message, the brand agent may terminate the session. Hosts SHOULD warn users before timeout when possible.', ge=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar negotiated_capabilities : SiCapabilities | Nonevar response : Response | Nonevar session_id : strvar session_status : SiSessionStatusvar session_ttl_seconds : int | None
Inherited members
class SiSendMessageRequest (**data: Any)-
Expand source code
class SiSendMessageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = None ext: ext_1.ExtensionObject | None = None message: Annotated[str | None, Field(description="User's message to the brand agent")] = None session_id: Annotated[str, Field(description='Active session identifier')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var action_response : ActionResponse | Nonevar ext : ExtensionObject | Nonevar message : str | Nonevar model_configvar session_id : str
class SiSendTextMessageRequest (**data: Any)-
Expand source code
class SiSendMessageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = None ext: ext_1.ExtensionObject | None = None message: Annotated[str | None, Field(description="User's message to the brand agent")] = None session_id: Annotated[str, Field(description='Active session identifier')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var action_response : ActionResponse | Nonevar ext : ExtensionObject | Nonevar message : str | Nonevar model_configvar session_id : str
class SiSendActionResponseRequest (**data: Any)-
Expand source code
class SiSendMessageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = None ext: ext_1.ExtensionObject | None = None message: Annotated[str | None, Field(description="User's message to the brand agent")] = None session_id: Annotated[str, Field(description='Active session identifier')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var action_response : ActionResponse | Nonevar ext : ExtensionObject | Nonevar message : str | Nonevar model_configvar session_id : str
Inherited members
class SiSendMessageResponse (**data: Any)-
Expand source code
class SiSendMessageResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) errors: list[error.Error] | None = None ext: ext_1.ExtensionObject | None = None handoff: Annotated[ Handoff | None, Field(description='Handoff request when session_status is pending_handoff') ] = None mcp_resource_uri: Annotated[ str | None, Field( description='MCP resource URI for hosts with MCP Apps support (e.g., ui://si/session-abc123)' ), ] = None response: Annotated[Response | None, Field(description="Brand agent's response")] = None session_id: Annotated[str, Field(description='Session identifier')] session_status: Annotated[ si_session_status.SiSessionStatus, Field( description='Current session status. On a successful response, one of: active, pending_handoff, or complete. Terminated sessions return error codes (SESSION_NOT_FOUND or SESSION_TERMINATED) instead of a success response.' ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar handoff : Handoff | Nonevar mcp_resource_uri : str | Nonevar model_configvar response : Response | Nonevar session_id : strvar session_status : SiSessionStatus
Inherited members
class SiTerminateSessionRequest (**data: Any)-
Expand source code
class SiTerminateSessionRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) ext: ext_1.ExtensionObject | None = None reason: Annotated[Reason, Field(description='Reason for termination')] session_id: Annotated[str, Field(description='Session identifier to terminate')] termination_context: Annotated[ TerminationContext | None, Field(description='Context for the termination') ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var ext : ExtensionObject | Nonevar model_configvar reason : Reasonvar session_id : strvar termination_context : TerminationContext | None
Inherited members
class SiTerminateSessionResponse (**data: Any)-
Expand source code
class SiTerminateSessionResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) acp_handoff: Annotated[ AcpHandoff | None, Field(description='ACP checkout handoff data. Present when reason is handoff_transaction.'), ] = None errors: list[error.Error] | None = None ext: ext_1.ExtensionObject | None = None follow_up: Annotated[FollowUp | None, Field(description='Suggested follow-up actions')] = None session_id: Annotated[str, Field(description='Terminated session identifier')] session_status: Annotated[ si_session_status.SiSessionStatus | None, Field( description="Resulting session state. 'complete' for handoff_transaction/handoff_complete, 'terminated' for user_exit/session_timeout/host_terminated." ), ] = None terminated: Annotated[bool, Field(description='Whether session was successfully terminated')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var acp_handoff : AcpHandoff | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar follow_up : FollowUp | Nonevar model_configvar session_id : strvar session_status : SiSessionStatus | Nonevar terminated : bool
Inherited members
class SiUiElement (**data: Any)-
Expand source code
class SiUiElement(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) data: Annotated[dict[str, Any] | None, Field(description='Component-specific data')] = None type: Annotated[Type, Field(description='Component type')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var data : dict[str, typing.Any] | Nonevar model_configvar type : Type
Inherited members
class Signal (**data: Any)-
Expand source code
class Signal(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) categories: Annotated[ list[str] | None, Field( description="Valid values for categorical signals. Present when value_type is 'categorical'. Buyers must use one of these values in SignalTargeting.values." ), ] = None coverage_percentage: Annotated[ float, Field(description='Percentage of audience coverage', ge=0.0, le=100.0) ] data_provider: Annotated[str, Field(description='Human-readable name of the data provider')] deployments: Annotated[ list[deployment.Deployment], Field(description='Array of deployment targets') ] description: Annotated[str, Field(description='Detailed signal description')] name: Annotated[str, Field(description='Human-readable signal name')] pricing_options: Annotated[ list[signal_pricing_option.SignalPricingOption], Field( description='Pricing options available for this signal. The buyer selects one and passes its pricing_option_id in report_usage for billing verification.', min_length=1, ), ] range: Annotated[ Range | None, Field(description="Valid range for numeric signals. Present when value_type is 'numeric'."), ] = None signal_agent_segment_id: Annotated[ str, Field( description="Opaque identifier used for activation. This is the signals agent's internal segment ID." ), ] signal_id: Annotated[ signal_id_1.SignalId | None, Field( description="Universal signal identifier referencing the data provider's catalog. Use this to verify authorization and look up signal definitions." ), ] = None signal_type: Annotated[ signal_catalog_type.SignalCatalogType, Field(description='Catalog type of signal (marketplace, custom, owned)'), ] value_type: Annotated[ signal_value_type.SignalValueType | None, Field(description="The data type of this signal's values (binary, categorical, numeric)"), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var categories : list[str] | Nonevar coverage_percentage : floatvar data_provider : strvar deployments : list[Deployment]var description : strvar model_configvar name : strvar pricing_options : list[SignalPricingOption]var range : Range | Nonevar signal_agent_segment_id : strvar signal_id : SignalId | Nonevar signal_type : SignalCatalogTypevar value_type : SignalValueType | None
Inherited members
class SignalCatalogType (*args, **kwds)-
Expand source code
class SignalCatalogType(Enum): marketplace = 'marketplace' custom = 'custom' owned = 'owned'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var customvar marketplacevar owned
class SignalType (*args, **kwds)-
Expand source code
class SignalCatalogType(Enum): marketplace = 'marketplace' custom = 'custom' owned = 'owned'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var customvar marketplacevar owned
class SignalFilters (**data: Any)-
Expand source code
class SignalFilters(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalog_types: Annotated[ list[signal_catalog_type.SignalCatalogType] | None, Field(description='Filter by catalog type', min_length=1), ] = None data_providers: Annotated[ list[str] | None, Field(description='Filter by specific data providers', min_length=1) ] = None max_cpm: Annotated[ float | None, Field(description="Maximum CPM filter. Applies only to signals with model='cpm'.", ge=0.0), ] = None max_percent: Annotated[ float | None, Field( description='Maximum percent-of-media rate filter. Signals where all percent_of_media pricing options exceed this value are excluded. Does not account for max_cpm caps.', ge=0.0, le=100.0, ), ] = None min_coverage_percentage: Annotated[ float | None, Field(description='Minimum coverage requirement', ge=0.0, le=100.0) ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalog_types : list[SignalCatalogType] | Nonevar data_providers : list[str] | Nonevar max_cpm : float | Nonevar max_percent : float | Nonevar min_coverage_percentage : float | Nonevar model_config
Inherited members
class SignalPricing (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class SignalPricing(RootModel[SignalPricing1 | SignalPricing2 | SignalPricing3]): root: Annotated[ SignalPricing1 | SignalPricing2 | SignalPricing3, Field( description="Pricing model for a signal. Discriminated by model: 'cpm' (fixed CPM), 'percent_of_media' (percentage of spend with optional CPM cap), or 'flat_fee' (fixed charge per reporting period, e.g. monthly licensed segments).", title='Signal Pricing', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[SignalPricing1, SignalPricing2, SignalPricing3]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : SignalPricing1 | SignalPricing2 | SignalPricing3
class SignalPricingOption (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class SignalPricingOption( RootModel[SignalPricingOption5 | SignalPricingOption6 | SignalPricingOption7] ): root: Annotated[ SignalPricingOption5 | SignalPricingOption6 | SignalPricingOption7, Field( description='A pricing option offered by a signals agent. Combines pricing_option_id with the signal pricing model fields at the same level — pass pricing_option_id in report_usage for billing verification.', title='Signal Pricing Option', ), ] 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
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[Union[SignalPricingOption5, SignalPricingOption6, SignalPricingOption7]]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : SignalPricingOption5 | SignalPricingOption6 | SignalPricingOption7
class CpmSignalPricingOption (**data: Any)-
Expand source code
class SignalPricingOption5(SignalPricingOption1, SignalPricingOption4): passBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- SignalPricingOption1
- SignalPricingOption4
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class PercentOfMediaSignalPricingOption (**data: Any)-
Expand source code
class SignalPricingOption6(SignalPricingOption2, SignalPricingOption4): passBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- SignalPricingOption2
- SignalPricingOption4
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class FlatFeeSignalPricingOption (**data: Any)-
Expand source code
class SignalPricingOption7(SignalPricingOption3, SignalPricingOption4): passBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- SignalPricingOption3
- SignalPricingOption4
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class Snapshot (**data: Any)-
Expand source code
class Snapshot(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) as_of: Annotated[ AwareDatetime, Field(description='When this snapshot was captured by the platform') ] impressions: Annotated[ int, Field( description='Lifetime impressions across all assignments. Not scoped to any date range.', ge=0, ), ] last_served: Annotated[ AwareDatetime | None, Field( description='Last time this creative served an impression. Absent when the creative has never served.' ), ] = None staleness_seconds: Annotated[ int, Field( description='Maximum age of this data in seconds. For example, 3600 means the data may be up to 1 hour old.', ge=0, ), ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var as_of : pydantic.types.AwareDatetimevar impressions : intvar last_served : pydantic.types.AwareDatetime | Nonevar model_configvar staleness_seconds : int
Inherited members
-
Expand source code
class SnapshotUnavailableReason(Enum): SNAPSHOT_UNSUPPORTED = 'SNAPSHOT_UNSUPPORTED' SNAPSHOT_TEMPORARILY_UNAVAILABLE = 'SNAPSHOT_TEMPORARILY_UNAVAILABLE' SNAPSHOT_PERMISSION_DENIED = 'SNAPSHOT_PERMISSION_DENIED'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
class Sort (**data: Any)-
Expand source code
class Sort(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) direction: Annotated[ sort_direction.SortDirection | None, Field(description='Sort direction') ] = sort_direction.SortDirection.desc field: Annotated[ creative_sort_field.CreativeSortField | None, Field(description='Field to sort by') ] = creative_sort_field.CreativeSortField.created_dateBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var direction : SortDirection | Nonevar field : CreativeSortField | Nonevar model_config
Inherited members
class SortApplied (**data: Any)-
Expand source code
class SortApplied(AdCPBaseModel): direction: sort_direction.SortDirection | None = None field: str | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var direction : SortDirection | Nonevar field : str | Nonevar model_config
Inherited members
class SortDirection (*args, **kwds)-
Expand source code
class SortDirection(Enum): asc = 'asc' desc = 'desc'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var ascvar desc
class Status (*args, **kwds)-
Expand source code
class Status(Enum): pending_activation = 'pending_activation' pending = 'pending' active = 'active' paused = 'paused' completed = 'completed' rejected = 'rejected' canceled = 'canceled' failed = 'failed' reporting_delayed = 'reporting_delayed'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var activevar canceledvar completedvar failedvar pausedvar pendingvar pending_activationvar rejectedvar reporting_delayed
class MediaBuyDeliveryStatus (*args, **kwds)-
Expand source code
class Status(Enum): pending_activation = 'pending_activation' pending = 'pending' active = 'active' paused = 'paused' completed = 'completed' rejected = 'rejected' canceled = 'canceled' failed = 'failed' reporting_delayed = 'reporting_delayed'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var activevar canceledvar completedvar failedvar pausedvar pendingvar pending_activationvar rejectedvar reporting_delayed
class StatusSummary (**data: Any)-
Expand source code
class StatusSummary(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) approved: Annotated[int | None, Field(description='Number of approved creatives', ge=0)] = None archived: Annotated[int | None, Field(description='Number of archived creatives', ge=0)] = None pending_review: Annotated[ int | None, Field(description='Number of creatives pending review', ge=0) ] = None processing: Annotated[ int | None, Field(description='Number of creatives being processed', ge=0) ] = None rejected: Annotated[int | None, Field(description='Number of rejected creatives', ge=0)] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var approved : int | Nonevar archived : int | Nonevar model_configvar pending_review : int | Nonevar processing : int | Nonevar rejected : int | None
Inherited members
class SyncAccountsRequest (**data: Any)-
Expand source code
class SyncAccountsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accounts: Annotated[ list[Account], Field(description='Advertiser accounts to sync', max_length=1000) ] context: context_1.ContextObject | None = None delete_missing: Annotated[ bool | None, Field( description='When true, accounts previously synced by this agent but not included in this request will be deactivated. Scoped to the authenticated agent — does not affect accounts managed by other agents. Use with caution.' ), ] = False dry_run: Annotated[ bool | None, Field( description='When true, preview what would change without applying. Returns what would be created/updated/deactivated.' ), ] = False ext: ext_1.ExtensionObject | None = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Webhook for async notifications when account status changes (e.g., pending_approval transitions to active).' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accounts : list[Account]var context : ContextObject | Nonevar delete_missing : bool | Nonevar dry_run : bool | Nonevar ext : ExtensionObject | Nonevar model_configvar push_notification_config : PushNotificationConfig | None
Inherited members
class SyncAccountsSuccessResponse (**data: Any)-
Expand source code
class SyncAccountsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) accounts: Annotated[list[Account], Field(description='Results for each account processed')] context: context_1.ContextObject | None = None dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = None ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var accounts : list[Account]var context : ContextObject | Nonevar dry_run : bool | Nonevar ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncAccountsErrorResponse (**data: Any)-
Expand source code
class SyncAccountsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field( description='Operation-level errors (e.g., authentication failure, service unavailable)', min_length=1, ), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncAudiencesRequest (**data: Any)-
Expand source code
class SyncAudiencesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account to manage audiences for.') ] audiences: Annotated[ list[Audience] | None, Field( description='Audiences to sync (create or update). When omitted, the call is discovery-only and returns all existing audiences on the account without modification.', min_length=1, ), ] = None context: context_1.ContextObject | None = None delete_missing: Annotated[ bool | None, Field( description='When true, buyer-managed audiences on the account not included in this sync will be removed. Does not affect seller-managed audiences. Do not combine with an omitted audiences array or all buyer-managed audiences will be deleted.' ), ] = False ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar audiences : list[Audience] | Nonevar context : ContextObject | Nonevar delete_missing : bool | Nonevar ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncAudiencesSuccessResponse (**data: Any)-
Expand source code
class SyncAudiencesResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) audiences: Annotated[ list[Audience], Field(description='Results for each audience on the account') ] context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var audiences : list[Audience]var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class SyncAudiencesErrorResponse (**data: Any)-
Expand source code
class SyncAudiencesResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field(description='Operation-level errors that prevented processing', min_length=1), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncCatalogsInputRequired (**data: Any)-
Expand source code
class SyncCatalogsInputRequired(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None reason: Annotated[ Reason | None, Field( description='Reason code indicating why buyer input is needed. APPROVAL_REQUIRED: platform requires explicit approval before activating the catalog. FEED_VALIDATION: feed URL returned unexpected format or schema errors. ITEM_REVIEW: platform flagged items for manual review. FEED_ACCESS: platform cannot access the feed URL (authentication, CORS, etc.).' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar reason : Reason | None
Inherited members
class SyncCatalogsRequest (**data: Any)-
Expand source code
class SyncCatalogsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account that owns these catalogs.') ] catalog_ids: Annotated[ list[str] | None, Field( description='Optional filter to limit sync scope to specific catalog IDs. When provided, only these catalogs will be created/updated. Other catalogs on the account are unaffected.', max_length=50, min_length=1, ), ] = None catalogs: Annotated[ list[catalog.Catalog] | None, Field( description='Array of catalog feeds to sync (create or update). When omitted, the call is discovery-only and returns all existing catalogs on the account without modification.', max_length=50, min_length=1, ), ] = None context: context_1.ContextObject | None = None delete_missing: Annotated[ bool | None, Field( description='When true, buyer-managed catalogs on the account not included in this sync will be removed. Does not affect seller-managed catalogs. Do not combine with an omitted catalogs array or all buyer-managed catalogs will be deleted.' ), ] = False dry_run: Annotated[ bool | None, Field( description='When true, preview changes without applying them. Returns what would be created/updated/deleted.' ), ] = False ext: ext_1.ExtensionObject | None = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async sync notifications. Publisher will send webhook when sync completes if operation takes longer than immediate response time (common for large feeds requiring platform review).' ), ] = None validation_mode: Annotated[ validation_mode_1.ValidationMode | None, Field( description="Validation strictness. 'strict' fails entire sync on any validation error. 'lenient' processes valid catalogs and reports errors." ), ] = validation_mode_1.ValidationMode.strictBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar catalog_ids : list[str] | Nonevar catalogs : list[Catalog] | Nonevar context : ContextObject | Nonevar delete_missing : bool | Nonevar dry_run : bool | Nonevar ext : ExtensionObject | Nonevar model_configvar push_notification_config : PushNotificationConfig | Nonevar validation_mode : ValidationMode | None
Inherited members
class SyncCatalogsSuccessResponse (**data: Any)-
Expand source code
class SyncCatalogsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalogs: Annotated[ list[Catalog], Field( description="Results for each catalog processed. Items with action='failed' indicate per-catalog validation/processing failures, not operation-level failures." ), ] context: context_1.ContextObject | None = None dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = None ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalogs : list[Catalog]var context : ContextObject | Nonevar dry_run : bool | Nonevar ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class SyncCatalogsErrorResponse (**data: Any)-
Expand source code
class SyncCatalogsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field( description='Operation-level errors that prevented processing any catalogs (e.g., authentication failure, service unavailable, invalid request format)', min_length=1, ), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncCatalogsSubmitted (**data: Any)-
Expand source code
class SyncCatalogsSubmitted(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncCatalogsWorking (**data: Any)-
Expand source code
class SyncCatalogsWorking(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) catalogs_processed: Annotated[ int | None, Field(description='Number of catalogs processed so far', ge=0) ] = None catalogs_total: Annotated[ int | None, Field(description='Total number of catalogs to process', ge=0) ] = None context: context_1.ContextObject | None = None current_step: Annotated[ str | None, Field( description="Current step or phase of the operation (e.g., 'Fetching product feed', 'Validating items', 'Platform review')" ), ] = None ext: ext_1.ExtensionObject | None = None items_processed: Annotated[ int | None, Field(description='Total number of catalog items processed across all catalogs', ge=0), ] = None items_total: Annotated[ int | None, Field(description='Total number of catalog items to process across all catalogs', ge=0), ] = None percentage: Annotated[ float | None, Field(description='Completion percentage (0-100)', ge=0.0, le=100.0) ] = None step_number: Annotated[int | None, Field(description='Current step number', ge=1)] = None total_steps: Annotated[ int | None, Field(description='Total number of steps in the operation', ge=1) ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var catalogs_processed : int | Nonevar catalogs_total : int | Nonevar context : ContextObject | Nonevar current_step : str | Nonevar ext : ExtensionObject | Nonevar items_processed : int | Nonevar items_total : int | Nonevar model_configvar percentage : float | Nonevar step_number : int | Nonevar total_steps : int | None
Inherited members
class SyncCreativesRequest (**data: Any)-
Expand source code
class SyncCreativesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account that owns these creatives.') ] assignments: Annotated[ list[Assignment] | None, Field( description='Optional bulk assignment of creatives to packages. Each entry maps one creative to one package with optional weight and placement targeting. Standalone creative agents that do not manage media buys ignore this field.', min_length=1, ), ] = None context: context_1.ContextObject | None = None creative_ids: Annotated[ list[str] | None, Field( description='Optional filter to limit sync scope to specific creative IDs. When provided, only these creatives will be created/updated. Other creatives in the library are unaffected. Useful for partial updates and error recovery.', max_length=100, min_length=1, ), ] = None creatives: Annotated[ list[creative_asset.CreativeAsset], Field( description='Array of creative assets to sync (create or update)', max_length=100, min_length=1, ), ] delete_missing: Annotated[ bool | None, Field( description='When true, creatives not included in this sync will be archived. Use with caution for full library replacement. Invalid when creative_ids is provided — delete_missing applies to the entire library scope, not a filtered subset.' ), ] = False dry_run: Annotated[ bool | None, Field( description='When true, preview changes without applying them. Returns what would be created/updated/deleted.' ), ] = False ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated idempotency key for safe retries. If a sync fails without a response, resending with the same idempotency_key guarantees at-most-once execution. 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, ), ] = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async sync notifications. The agent will send a webhook when sync completes if the operation takes longer than immediate response time (typically for large bulk operations or manual approval/HITL).' ), ] = None validation_mode: Annotated[ validation_mode_1.ValidationMode | None, Field( description="Validation strictness. 'strict' fails entire sync on any validation error. 'lenient' processes valid creatives and reports errors." ), ] = validation_mode_1.ValidationMode.strictBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar assignments : list[Assignment] | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar creatives : list[CreativeAsset]var delete_missing : bool | Nonevar dry_run : bool | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar push_notification_config : PushNotificationConfig | Nonevar validation_mode : ValidationMode | None
Inherited members
class SyncCreativesSuccessResponse (**data: Any)-
Expand source code
class SyncCreativesResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None creatives: Annotated[ list[Creative], Field( description="Results for each creative processed. Items with action='failed' indicate per-item validation/processing failures, not operation-level failures." ), ] dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = None ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar creatives : list[Creative]var dry_run : bool | Nonevar ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class SyncCreativesErrorResponse (**data: Any)-
Expand source code
class SyncCreativesResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field( description='Operation-level errors that prevented processing any creatives (e.g., authentication failure, service unavailable, invalid request format)', min_length=1, ), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncEventSourcesRequest (**data: Any)-
Expand source code
class SyncEventSourcesRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) account: Annotated[ account_ref.AccountReference, Field(description='Account to configure event sources for.') ] context: context_1.ContextObject | None = None delete_missing: Annotated[ bool | None, Field(description='When true, event sources not included in this sync will be removed'), ] = False event_sources: Annotated[ list[EventSource] | None, Field( description='Event sources to sync (create or update). When omitted, the call is discovery-only and returns all existing event sources on the account without modification.', min_length=1, ), ] = None ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var account : AccountReferencevar context : ContextObject | Nonevar delete_missing : bool | Nonevar event_sources : list[EventSource] | Nonevar ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncEventSourcesSuccessResponse (**data: Any)-
Expand source code
class SyncEventSourcesResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None event_sources: Annotated[ list[EventSource], Field( description='Results for each event source, including both synced and seller-managed sources on the account' ), ] ext: ext_1.ExtensionObject | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar event_sources : list[EventSource]var ext : ExtensionObject | Nonevar model_configvar sandbox : bool | None
Inherited members
class SyncEventSourcesErrorResponse (**data: Any)-
Expand source code
class SyncEventSourcesResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field(description='Operation-level errors that prevented processing', min_length=1), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class SyncPlansRequest (**data: Any)-
Expand source code
class SyncPlansRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) plans: Annotated[list[Plan], Field(description='One or more campaign plans to sync.')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar plans : list[Plan]
Inherited members
class SyncPlansResponse (**data: Any)-
Expand source code
class SyncPlansResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) plans: Annotated[list[Plan], Field(description='Status for each synced plan.')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_configvar plans : list[Plan]
Inherited members
class Tags (**data: Any)-
Expand source code
class Tags(SignalTags): passBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- SignalTags
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var model_config
Inherited members
class TargetingOverlay (**data: Any)-
Expand source code
class TargetingOverlay(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) age_restriction: Annotated[ AgeRestriction | None, Field( description='Age restriction for compliance. Use for legal requirements (alcohol, gambling), not audience targeting.' ), ] = None audience_exclude: Annotated[ list[str] | None, Field( description='Suppress delivery to members of these first-party CRM audiences. Matched users are excluded regardless of other targeting. References audience_id values from sync_audiences on the same seller account — audience IDs are not portable across sellers. Seller must declare support in get_adcp_capabilities.', min_length=1, ), ] = None audience_include: Annotated[ list[str] | None, Field( description='Restrict delivery to members of these first-party CRM audiences. Only users present in the uploaded lists are eligible. References audience_id values from sync_audiences on the same seller account — audience IDs are not portable across sellers. Not for lookalike expansion — express that intent in the campaign brief. Seller must declare support in get_adcp_capabilities.', min_length=1, ), ] = None axe_exclude_segment: Annotated[ str | None, Field( deprecated=True, description='Deprecated: Use TMP provider fields instead. AXE segment ID to exclude from targeting.', ), ] = None axe_include_segment: Annotated[ str | None, Field( deprecated=True, description='Deprecated: Use TMP provider fields instead. AXE segment ID to include for targeting.', ), ] = None daypart_targets: Annotated[ list[daypart_target.DaypartTarget] | None, Field( description='Restrict delivery to specific time windows. Each entry specifies days of week and an hour range.', min_length=1, ), ] = None device_platform: Annotated[ list[device_platform_1.DevicePlatform] | None, Field( description='Restrict to specific platforms. Use for technical compatibility (app only works on iOS). Values from Sec-CH-UA-Platform standard, extended for CTV.', min_length=1, ), ] = None device_type: Annotated[ list[device_type_1.DeviceType] | None, Field( description='Restrict to specific device form factors. Use for campaigns targeting hardware categories rather than operating systems (e.g., mobile-only promotions, CTV campaigns).', min_length=1, ), ] = None device_type_exclude: Annotated[ list[device_type_1.DeviceType] | None, Field( description='Exclude specific device form factors from delivery (e.g., exclude CTV for app-install campaigns).', min_length=1, ), ] = None frequency_cap: frequency_cap_1.FrequencyCap | None = None geo_countries: Annotated[ list[GeoCountry] | None, Field( description="Restrict delivery to specific countries. ISO 3166-1 alpha-2 codes (e.g., 'US', 'GB', 'DE').", min_length=1, ), ] = None geo_countries_exclude: Annotated[ list[GeoCountriesExcludeItem] | None, Field( description="Exclude specific countries from delivery. ISO 3166-1 alpha-2 codes (e.g., 'US', 'GB', 'DE').", min_length=1, ), ] = None geo_metros: Annotated[ list[GeoMetro] | None, Field( description='Restrict delivery to specific metro areas. Each entry specifies the classification system and target values. Seller must declare supported systems in get_adcp_capabilities.', min_length=1, ), ] = None geo_metros_exclude: Annotated[ list[GeoMetrosExcludeItem] | None, Field( description='Exclude specific metro areas from delivery. Each entry specifies the classification system and excluded values. Seller must declare supported systems in get_adcp_capabilities.', min_length=1, ), ] = None geo_postal_areas: Annotated[ list[GeoPostalArea] | None, Field( description='Restrict delivery to specific postal areas. Each entry specifies the postal system and target values. Seller must declare supported systems in get_adcp_capabilities.', min_length=1, ), ] = None geo_postal_areas_exclude: Annotated[ list[GeoPostalAreasExcludeItem] | None, Field( description='Exclude specific postal areas from delivery. Each entry specifies the postal system and excluded values. Seller must declare supported systems in get_adcp_capabilities.', min_length=1, ), ] = None geo_proximity: Annotated[ list[GeoProximity | GeoProximity5 | GeoProximity6] | None, Field( description='Target users within travel time, distance, or a custom boundary around arbitrary geographic points. Multiple entries use OR semantics — a user within range of any listed point is eligible. For campaigns targeting 10+ locations, consider using store_catchments with a location catalog instead. Seller must declare support in get_adcp_capabilities.', min_length=1, ), ] = None geo_regions: Annotated[ list[GeoRegion] | None, Field( description="Restrict delivery to specific regions/states. ISO 3166-2 subdivision codes (e.g., 'US-CA', 'GB-SCT').", min_length=1, ), ] = None geo_regions_exclude: Annotated[ list[GeoRegionsExcludeItem] | None, Field( description="Exclude specific regions/states from delivery. ISO 3166-2 subdivision codes (e.g., 'US-CA', 'GB-SCT').", min_length=1, ), ] = None keyword_targets: Annotated[ list[KeywordTarget] | None, Field( description='Keyword targeting for search and retail media platforms. Restricts delivery to queries matching the specified keywords. Each keyword is identified by the tuple (keyword, match_type) — the same keyword string with different match types are distinct targets. Sellers SHOULD reject duplicate (keyword, match_type) pairs within a single request. Seller must declare support in get_adcp_capabilities.', min_length=1, ), ] = None language: Annotated[ list[LanguageItem] | None, Field( description="Restrict to users with specific language preferences. ISO 639-1 codes (e.g., 'en', 'es', 'fr').", min_length=1, ), ] = None negative_keywords: Annotated[ list[NegativeKeyword] | None, Field( description='Keywords to exclude from delivery. Queries matching these keywords will not trigger the ad. Each negative keyword is identified by the tuple (keyword, match_type). Seller must declare support in get_adcp_capabilities.', min_length=1, ), ] = None property_list: Annotated[ property_list_ref.PropertyListReference | None, Field( description="Reference to a property list for targeting specific properties within this product. The package runs on the intersection of the product's publisher_properties and this list. Sellers SHOULD return a validation error if the product has property_targeting_allowed: false." ), ] = None store_catchments: Annotated[ list[StoreCatchment] | None, Field( description='Target users within store catchment areas from a synced store catalog. Each entry references a store-type catalog and optionally narrows to specific stores or catchment zones.', min_length=1, ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var age_restriction : AgeRestriction | Nonevar audience_exclude : list[str] | Nonevar audience_include : list[str] | Nonevar daypart_targets : list[DaypartTarget] | Nonevar device_platform : list[DevicePlatform] | Nonevar device_type : list[DeviceType] | Nonevar device_type_exclude : list[DeviceType] | Nonevar frequency_cap : FrequencyCap | Nonevar geo_countries : list[GeoCountry] | Nonevar geo_countries_exclude : list[GeoCountriesExcludeItem] | Nonevar geo_metros : list[GeoMetro] | Nonevar geo_metros_exclude : list[GeoMetrosExcludeItem] | Nonevar geo_postal_areas : list[GeoPostalArea] | Nonevar geo_postal_areas_exclude : list[GeoPostalAreasExcludeItem] | Nonevar geo_proximity : list[GeoProximity | GeoProximity5 | GeoProximity6] | Nonevar geo_regions : list[GeoRegion] | Nonevar geo_regions_exclude : list[GeoRegionsExcludeItem] | Nonevar keyword_targets : list[KeywordTarget] | Nonevar language : list[LanguageItem] | Nonevar model_configvar negative_keywords : list[NegativeKeyword] | Nonevar property_list : PropertyListReference | Nonevar store_catchments : list[StoreCatchment] | None
Instance variables
var axe_exclude_segment : str | None-
Expand source code
def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any: if obj is None: if self.wrapped_property is not None: return self.wrapped_property.__get__(None, obj_type) raise AttributeError(self.field_name) warnings.warn(self.msg, DeprecationWarning, stacklevel=2) if self.wrapped_property is not None: return self.wrapped_property.__get__(obj, obj_type) return obj.__dict__[self.field_name]Read-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field.
Attributes
msg- The deprecation message to be emitted.
wrapped_property- The property instance if the deprecated field is a computed field, or
None. field_name- The name of the field being deprecated.
var axe_include_segment : str | None-
Expand source code
def __get__(self, obj: BaseModel | None, obj_type: type[BaseModel] | None = None) -> Any: if obj is None: if self.wrapped_property is not None: return self.wrapped_property.__get__(None, obj_type) raise AttributeError(self.field_name) warnings.warn(self.msg, DeprecationWarning, stacklevel=2) if self.wrapped_property is not None: return self.wrapped_property.__get__(obj, obj_type) return obj.__dict__[self.field_name]Read-only data descriptor used to emit a runtime deprecation warning before accessing a deprecated field.
Attributes
msg- The deprecation message to be emitted.
wrapped_property- The property instance if the deprecated field is a computed field, or
None. field_name- The name of the field being deprecated.
Inherited members
class TaskResult (**data: Any)-
Expand source code
class TaskResult(BaseModel, Generic[T]): """Result from task execution.""" model_config = ConfigDict(arbitrary_types_allowed=True) status: TaskStatus data: T | None = None message: str | None = None # Human-readable message from agent (e.g., MCP content text) submitted: SubmittedInfo | None = None needs_input: NeedsInputInfo | None = None error: str | None = None success: bool = Field(default=True) metadata: dict[str, Any] | None = None debug_info: DebugInfo | None = NoneResult from task execution.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
- typing.Generic
Subclasses
- adcp.types.core.TaskResult[AdcpAsyncResponseData]
- adcp.types.core.TaskResult[Any]
- adcp.types.core.TaskResult[CheckGovernanceResponse]
- adcp.types.core.TaskResult[ContextMatchResponse]
- adcp.types.core.TaskResult[CreatePropertyListResponse]
- adcp.types.core.TaskResult[DeletePropertyListResponse]
- adcp.types.core.TaskResult[GetAdcpCapabilitiesResponse]
- adcp.types.core.TaskResult[GetCreativeDeliveryResponse]
- adcp.types.core.TaskResult[GetMediaBuyDeliveryResponse]
- adcp.types.core.TaskResult[GetMediaBuysResponse]
- adcp.types.core.TaskResult[GetPlanAuditLogsResponse]
- adcp.types.core.TaskResult[GetProductsResponse]
- adcp.types.core.TaskResult[GetPropertyListResponse]
- adcp.types.core.TaskResult[GetSignalsResponse]
- adcp.types.core.TaskResult[IdentityMatchResponse]
- adcp.types.core.TaskResult[ListAccountsResponse]
- adcp.types.core.TaskResult[ListCreativeFormatsResponse]
- adcp.types.core.TaskResult[ListCreativesResponse]
- adcp.types.core.TaskResult[ListPropertyListsResponse]
- adcp.types.core.TaskResult[ReportPlanOutcomeResponse]
- adcp.types.core.TaskResult[ReportUsageResponse]
- adcp.types.core.TaskResult[SiGetOfferingResponse]
- adcp.types.core.TaskResult[SiInitiateSessionResponse]
- adcp.types.core.TaskResult[SiSendMessageResponse]
- adcp.types.core.TaskResult[SiTerminateSessionResponse]
- adcp.types.core.TaskResult[SyncPlansResponse]
- adcp.types.core.TaskResult[Union[AcquireRightsResponse1, AcquireRightsResponse2, AcquireRightsResponse3, AcquireRightsResponse4]]
- adcp.types.core.TaskResult[Union[ActivateSignalResponse1, ActivateSignalResponse2]]
- adcp.types.core.TaskResult[Union[BuildCreativeResponse1, BuildCreativeResponse2, BuildCreativeResponse3]]
- adcp.types.core.TaskResult[Union[CalibrateContentResponse1, CalibrateContentResponse2]]
- adcp.types.core.TaskResult[Union[ComplyTestControllerResponse1, ComplyTestControllerResponse2, ComplyTestControllerResponse3, ComplyTestControllerResponse4]]
- adcp.types.core.TaskResult[Union[CreateContentStandardsResponse1, CreateContentStandardsResponse2]]
- adcp.types.core.TaskResult[Union[CreateMediaBuyResponse1, CreateMediaBuyResponse2]]
- adcp.types.core.TaskResult[Union[GetAccountFinancialsResponse1, GetAccountFinancialsResponse2]]
- adcp.types.core.TaskResult[Union[GetBrandIdentityResponse1, GetBrandIdentityResponse2]]
- adcp.types.core.TaskResult[Union[GetContentStandardsResponse1, GetContentStandardsResponse2]]
- adcp.types.core.TaskResult[Union[GetCreativeFeaturesResponse1, GetCreativeFeaturesResponse2]]
- adcp.types.core.TaskResult[Union[GetMediaBuyArtifactsResponse1, GetMediaBuyArtifactsResponse2]]
- adcp.types.core.TaskResult[Union[GetRightsResponse1, GetRightsResponse2]]
- adcp.types.core.TaskResult[Union[ListContentStandardsResponse1, ListContentStandardsResponse2]]
- adcp.types.core.TaskResult[Union[LogEventResponse1, LogEventResponse2]]
- adcp.types.core.TaskResult[Union[PreviewCreativeResponse1, PreviewCreativeResponse2, PreviewCreativeResponse3]]
- adcp.types.core.TaskResult[Union[ProvidePerformanceFeedbackResponse1, ProvidePerformanceFeedbackResponse2]]
- adcp.types.core.TaskResult[Union[SyncAccountsResponse1, SyncAccountsResponse2]]
- adcp.types.core.TaskResult[Union[SyncAudiencesResponse1, SyncAudiencesResponse2]]
- adcp.types.core.TaskResult[Union[SyncCatalogsResponse1, SyncCatalogsResponse2]]
- adcp.types.core.TaskResult[Union[SyncCreativesResponse1, SyncCreativesResponse2]]
- adcp.types.core.TaskResult[Union[SyncEventSourcesResponse1, SyncEventSourcesResponse2]]
- adcp.types.core.TaskResult[Union[UpdateContentStandardsResponse1, UpdateContentStandardsResponse2]]
- adcp.types.core.TaskResult[Union[UpdateMediaBuyResponse1, UpdateMediaBuyResponse2]]
- adcp.types.core.TaskResult[Union[ValidateContentDeliveryResponse1, ValidateContentDeliveryResponse2]]
- adcp.types.core.TaskResult[UpdatePropertyListResponse]
Class variables
var data : ~T | Nonevar debug_info : DebugInfo | Nonevar error : str | Nonevar message : str | Nonevar metadata : dict[str, typing.Any] | Nonevar model_configvar needs_input : NeedsInputInfo | Nonevar status : TaskStatusvar submitted : SubmittedInfo | Nonevar success : bool
class GeneratedTaskStatus (*args, **kwds)-
Expand source code
class TaskStatus(Enum): submitted = 'submitted' working = 'working' input_required = 'input-required' completed = 'completed' canceled = 'canceled' failed = 'failed' rejected = 'rejected' auth_required = 'auth-required' unknown = 'unknown'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var auth_requiredvar canceledvar completedvar failedvar input_requiredvar rejectedvar submittedvar unknownvar working
class TaskType (*args, **kwds)-
Expand source code
class TaskType(Enum): create_media_buy = 'create_media_buy' update_media_buy = 'update_media_buy' sync_creatives = 'sync_creatives' activate_signal = 'activate_signal' get_signals = 'get_signals' create_property_list = 'create_property_list' update_property_list = 'update_property_list' get_property_list = 'get_property_list' list_property_lists = 'list_property_lists' delete_property_list = 'delete_property_list' sync_accounts = 'sync_accounts' get_account_financials = 'get_account_financials' get_creative_delivery = 'get_creative_delivery' sync_event_sources = 'sync_event_sources' sync_audiences = 'sync_audiences' sync_catalogs = 'sync_catalogs' log_event = 'log_event' get_brand_identity = 'get_brand_identity' get_rights = 'get_rights' acquire_rights = 'acquire_rights'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var acquire_rightsvar activate_signalvar create_media_buyvar create_property_listvar delete_property_listvar get_account_financialsvar get_brand_identityvar get_creative_deliveryvar get_property_listvar get_rightsvar get_signalsvar list_property_listsvar log_eventvar sync_accountsvar sync_audiencesvar sync_catalogsvar sync_creativesvar sync_event_sourcesvar update_media_buyvar update_property_list
class TextAsset (**data: Any)-
Expand source code
class TextAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) content: Annotated[str, Field(description='Text content')] language: Annotated[str | None, Field(description="Language code (e.g., 'en', 'es', 'fr')")] = ( None ) provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var content : strvar language : str | Nonevar model_configvar provenance : Provenance | None
Inherited members
class TextSubAsset (*args: object, **kwargs: object)-
Expand source code
class TextSubAsset: """Removed from ADCP schema. Previously SubAsset with asset_kind='text'.""" def __init__(self, *args: object, **kwargs: object) -> None: raise TypeError( "TextSubAsset was removed from the ADCP schema. " "There is no direct replacement." )Removed from ADCP schema. Previously SubAsset with asset_kind='text'.
class TimeBasedPricingOption (**data: Any)-
Expand source code
class TimeBasedPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Cost per time unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid per time unit for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None parameters: Annotated[Parameters, Field(description='Time-based pricing parameters')] price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['time'], Field(description='Cost per time unit - rate scales with campaign duration'), ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['time']var pricing_option_id : str
Inherited members
class TimeUnit (*args, **kwds)-
Expand source code
class TimeUnit(Enum): hour = 'hour' day = 'day' week = 'week' month = 'month'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dayvar hourvar monthvar week
class TmpError (**data: Any)-
Expand source code
class TmpError(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) code: Annotated[Code, Field(description='Machine-readable error code')] message: Annotated[ str | None, Field(description='Human-readable error description for debugging') ] = None request_id: Annotated[ str, Field(description='Echoed request identifier from the original request') ] type: Annotated[ Literal['error'], Field(description='Message type discriminator for deserialization.') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var code : Codevar message : str | Nonevar model_configvar request_id : strvar type : Literal['error']
Inherited members
class Totals (**data: Any)-
Expand source code
class Totals(DeliveryMetrics): effective_rate: Annotated[ float | None, Field( description="Effective rate paid per unit based on pricing_model (e.g., actual CPM for 'cpm', actual cost per completed view for 'cpcv', actual cost per point for 'cpp')", ge=0.0, ), ] = None spend: AnyBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- DeliveryMetrics
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var effective_rate : float | Nonevar model_configvar spend : Any
Inherited members
class Transform (*args, **kwds)-
Expand source code
class Transform(Enum): date = 'date' divide = 'divide' boolean = 'boolean' split = 'split'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var booleanvar datevar dividevar split
class UpdateContentStandardsRequest (**data: Any)-
Expand source code
class UpdateContentStandardsRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) calibration_exemplars: Annotated[ CalibrationExemplars | None, Field( description='Updated training/test set to calibrate policy interpretation. Use URL references for pages to be fetched and analyzed, or full artifacts for pre-extracted content.' ), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. 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, ), ] = None policy: Annotated[ str | None, Field( description='Updated natural language policy describing acceptable and unacceptable content contexts.' ), ] = None registry_policy_ids: Annotated[ list[str] | None, Field( description='Registry policy IDs to use as the evaluation basis. When provided, the agent resolves policies from the registry and uses their policy text and exemplars as the evaluation criteria.' ), ] = None scope: Annotated[ Scope | None, Field(description='Updated scope for where this standards configuration applies'), ] = None standards_id: Annotated[str, Field(description='ID of the standards configuration to update')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var calibration_exemplars : CalibrationExemplars | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar model_configvar policy : str | Nonevar registry_policy_ids : list[str] | Nonevar scope : Scope | Nonevar standards_id : str
Inherited members
class UpdateContentStandardsSuccessResponse (**data: Any)-
Expand source code
class UpdateContentStandardsResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None standards_id: Annotated[str, Field(description='ID of the updated standards configuration')] success: Annotated[ Literal[True], Field(description='Indicates the update was applied successfully') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar standards_id : strvar success : Literal[True]
Inherited members
class UpdateContentStandardsErrorResponse (**data: Any)-
Expand source code
class UpdateContentStandardsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) conflicting_standards_id: Annotated[ str | None, Field( description='If scope change conflicts with another configuration, the ID of the conflicting standards' ), ] = None context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field(description='Errors that occurred during the update', min_length=1) ] ext: ext_1.ExtensionObject | None = None success: Annotated[Literal[False], Field(description='Indicates the update failed')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var conflicting_standards_id : str | Nonevar context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_configvar success : Literal[False]
Inherited members
class UpdateFrequency (*args, **kwds)-
Expand source code
class UpdateFrequency(Enum): realtime = 'realtime' hourly = 'hourly' daily = 'daily' weekly = 'weekly'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var dailyvar hourlyvar realtimevar weekly
class UpdateMediaBuyRequest (**data: Any)-
Expand source code
class UpdateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) canceled: Annotated[ Literal[True], Field( description='Cancel the entire media buy. Cancellation is irreversible — canceled media buys cannot be reactivated. Sellers MAY reject with NOT_CANCELLABLE if the media buy cannot be canceled in its current state.' ), ] = True cancellation_reason: Annotated[ str | None, Field( description='Reason for cancellation. Sellers SHOULD store this and return it in subsequent get_media_buys responses.', max_length=500, ), ] = None context: context_1.ContextObject | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated idempotency key for safe retries. If an update fails without a response, resending with the same idempotency_key guarantees the update is applied at most once. 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, ), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description="Update who receives the invoice for this buy. When provided, the seller invoices this entity instead of the account's default billing_entity. The seller MUST validate the invoice recipient is authorized for this account. When governance_agents are configured, the seller MUST include invoice_recipient in the check_governance request." ), ] = None media_buy_id: Annotated[str, Field(description="Seller's ID of the media buy to update")] new_packages: Annotated[ list[package_request.PackageRequest] | None, Field( description='New packages to add to this media buy. Uses the same schema as create_media_buy packages. Sellers that support mid-flight package additions advertise add_packages in valid_actions. Sellers that do not support this MUST reject with UNSUPPORTED_FEATURE.', min_length=1, ), ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates for existing packages', min_length=1), ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async update notifications. Publisher will send webhook when update completes if operation takes longer than immediate response time. This is separate from reporting_webhook which configures ongoing campaign reporting.' ), ] = None reporting_webhook: Annotated[ reporting_webhook_1.ReportingWebhook | None, Field( description='Optional webhook configuration for automated reporting delivery. Updates the reporting configuration for this media buy.' ), ] = None revision: Annotated[ int | None, Field( description="Expected current revision for optimistic concurrency. When provided, sellers MUST reject the update with CONFLICT if the media buy's current revision does not match. Obtain from get_media_buys or the most recent update response.", ge=1, ), ] = None start_time: start_timing.StartTiming | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var canceled : Literal[True]var cancellation_reason : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar new_packages : list[PackageRequest] | Nonevar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar revision : int | Nonevar start_time : StartTiming | None
class UpdateMediaBuyPackagesRequest (**data: Any)-
Expand source code
class UpdateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) canceled: Annotated[ Literal[True], Field( description='Cancel the entire media buy. Cancellation is irreversible — canceled media buys cannot be reactivated. Sellers MAY reject with NOT_CANCELLABLE if the media buy cannot be canceled in its current state.' ), ] = True cancellation_reason: Annotated[ str | None, Field( description='Reason for cancellation. Sellers SHOULD store this and return it in subsequent get_media_buys responses.', max_length=500, ), ] = None context: context_1.ContextObject | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated idempotency key for safe retries. If an update fails without a response, resending with the same idempotency_key guarantees the update is applied at most once. 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, ), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description="Update who receives the invoice for this buy. When provided, the seller invoices this entity instead of the account's default billing_entity. The seller MUST validate the invoice recipient is authorized for this account. When governance_agents are configured, the seller MUST include invoice_recipient in the check_governance request." ), ] = None media_buy_id: Annotated[str, Field(description="Seller's ID of the media buy to update")] new_packages: Annotated[ list[package_request.PackageRequest] | None, Field( description='New packages to add to this media buy. Uses the same schema as create_media_buy packages. Sellers that support mid-flight package additions advertise add_packages in valid_actions. Sellers that do not support this MUST reject with UNSUPPORTED_FEATURE.', min_length=1, ), ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates for existing packages', min_length=1), ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async update notifications. Publisher will send webhook when update completes if operation takes longer than immediate response time. This is separate from reporting_webhook which configures ongoing campaign reporting.' ), ] = None reporting_webhook: Annotated[ reporting_webhook_1.ReportingWebhook | None, Field( description='Optional webhook configuration for automated reporting delivery. Updates the reporting configuration for this media buy.' ), ] = None revision: Annotated[ int | None, Field( description="Expected current revision for optimistic concurrency. When provided, sellers MUST reject the update with CONFLICT if the media buy's current revision does not match. Obtain from get_media_buys or the most recent update response.", ge=1, ), ] = None start_time: start_timing.StartTiming | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var canceled : Literal[True]var cancellation_reason : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar new_packages : list[PackageRequest] | Nonevar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar revision : int | Nonevar start_time : StartTiming | None
class UpdateMediaBuyPropertiesRequest (**data: Any)-
Expand source code
class UpdateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) canceled: Annotated[ Literal[True], Field( description='Cancel the entire media buy. Cancellation is irreversible — canceled media buys cannot be reactivated. Sellers MAY reject with NOT_CANCELLABLE if the media buy cannot be canceled in its current state.' ), ] = True cancellation_reason: Annotated[ str | None, Field( description='Reason for cancellation. Sellers SHOULD store this and return it in subsequent get_media_buys responses.', max_length=500, ), ] = None context: context_1.ContextObject | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None ext: ext_1.ExtensionObject | None = None idempotency_key: Annotated[ str | None, Field( description='Client-generated idempotency key for safe retries. If an update fails without a response, resending with the same idempotency_key guarantees the update is applied at most once. 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, ), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description="Update who receives the invoice for this buy. When provided, the seller invoices this entity instead of the account's default billing_entity. The seller MUST validate the invoice recipient is authorized for this account. When governance_agents are configured, the seller MUST include invoice_recipient in the check_governance request." ), ] = None media_buy_id: Annotated[str, Field(description="Seller's ID of the media buy to update")] new_packages: Annotated[ list[package_request.PackageRequest] | None, Field( description='New packages to add to this media buy. Uses the same schema as create_media_buy packages. Sellers that support mid-flight package additions advertise add_packages in valid_actions. Sellers that do not support this MUST reject with UNSUPPORTED_FEATURE.', min_length=1, ), ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates for existing packages', min_length=1), ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None push_notification_config: Annotated[ push_notification_config_1.PushNotificationConfig | None, Field( description='Optional webhook configuration for async update notifications. Publisher will send webhook when update completes if operation takes longer than immediate response time. This is separate from reporting_webhook which configures ongoing campaign reporting.' ), ] = None reporting_webhook: Annotated[ reporting_webhook_1.ReportingWebhook | None, Field( description='Optional webhook configuration for automated reporting delivery. Updates the reporting configuration for this media buy.' ), ] = None revision: Annotated[ int | None, Field( description="Expected current revision for optimistic concurrency. When provided, sellers MUST reject the update with CONFLICT if the media buy's current revision does not match. Obtain from get_media_buys or the most recent update response.", ge=1, ), ] = None start_time: start_timing.StartTiming | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var canceled : Literal[True]var cancellation_reason : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar new_packages : list[PackageRequest] | Nonevar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar revision : int | Nonevar start_time : StartTiming | None
Inherited members
class UpdateMediaBuySuccessResponse (**data: Any)-
Expand source code
class UpdateMediaBuyResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) affected_packages: Annotated[ list[package.Package] | None, Field(description='Array of packages that were modified with complete state information'), ] = None context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None implementation_date: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp when changes take effect (null if pending approval)'), ] = None invoice_recipient: Annotated[ business_entity.BusinessEntity | None, Field( description='Updated invoice recipient, echoed from the request when provided. Confirms the seller accepted the billing override. Bank details are omitted (write-only).' ), ] = None media_buy_id: Annotated[str, Field(description="Seller's identifier for the media buy")] revision: Annotated[ int | None, Field( description='Revision number after this update. Use this value in subsequent update_media_buy requests for optimistic concurrency.', ge=1, ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None status: Annotated[ media_buy_status.MediaBuyStatus | None, Field( description="Media buy status after the update. Present when the update changes the media buy's status (e.g., cancellation transitions to 'canceled', pause transitions to 'paused')." ), ] = None valid_actions: Annotated[ list[ValidAction] | None, Field( description='Actions the buyer can perform after this update. Saves a round-trip to get_media_buys.' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var affected_packages : list[Package] | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar implementation_date : pydantic.types.AwareDatetime | Nonevar invoice_recipient : BusinessEntity | Nonevar media_buy_id : strvar model_configvar revision : int | Nonevar sandbox : bool | Nonevar status : MediaBuyStatus | Nonevar valid_actions : list[ValidAction] | None
Inherited members
class UpdateMediaBuyErrorResponse (**data: Any)-
Expand source code
class UpdateMediaBuyResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) context: context_1.ContextObject | None = None errors: Annotated[ list[error.Error], Field(description='Array of errors explaining why the operation failed', min_length=1), ] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class UpdatePropertyListRequest (**data: Any)-
Expand source code
class UpdatePropertyListRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) base_properties: Annotated[ list[base_property_source.BasePropertySource] | None, Field( description='Complete replacement for the base properties list (not a patch). Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers).' ), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Update brand reference. Resolved to full brand identity at execution time.' ), ] = None context: context_1.ContextObject | None = None description: Annotated[str | None, Field(description='New description')] = None ext: ext_1.ExtensionObject | None = None filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Complete replacement for the filters (not a patch)'), ] = None idempotency_key: Annotated[ str | None, Field( description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. 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, ), ] = None list_id: Annotated[str, Field(description='ID of the property list to update')] name: Annotated[str | None, Field(description='New name for the list')] = None webhook_url: Annotated[ AnyUrl | None, Field( description='Update the webhook URL for list change notifications (set to empty string to remove)' ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var base_properties : list[BasePropertySource] | Nonevar brand : BrandReference | Nonevar context : ContextObject | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar filters : PropertyListFilters | Nonevar idempotency_key : str | Nonevar list_id : strvar model_configvar name : str | Nonevar webhook_url : pydantic.networks.AnyUrl | None
Inherited members
class UpdatePropertyListResponse (**data: Any)-
Expand source code
class UpdatePropertyListResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) ext: ext_1.ExtensionObject | None = None list: Annotated[property_list.PropertyList, Field(description='The updated property list')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var ext : ExtensionObject | Nonevar list : PropertyListvar model_config
Inherited members
class UrlAsset (**data: Any)-
Expand source code
class UrlAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) description: Annotated[ str | None, Field(description='Description of what this URL points to') ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None url: Annotated[AnyUrl, Field(description='URL reference')] url_type: Annotated[ url_asset_type.UrlAssetType | None, Field( description="Type of URL asset: 'clickthrough' for user click destination (landing page), 'tracker_pixel' for impression/event tracking via HTTP request (fires GET, expects pixel/204 response), 'tracker_script' for measurement SDKs that must load as <script> tag (OMID verification, native event trackers using method:2)" ), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var description : str | Nonevar model_configvar provenance : Provenance | Nonevar url : pydantic.networks.AnyUrlvar url_type : UrlAssetType | None
Inherited members
class UrlAssetType (*args, **kwds)-
Expand source code
class UrlAssetType(Enum): clickthrough = 'clickthrough' tracker_pixel = 'tracker_pixel' tracker_script = 'tracker_script'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var clickthroughvar tracker_pixelvar tracker_script
class UrlType (*args, **kwds)-
Expand source code
class UrlAssetType(Enum): clickthrough = 'clickthrough' tracker_pixel = 'tracker_pixel' tracker_script = 'tracker_script'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var clickthroughvar tracker_pixelvar tracker_script
class ValidateContentDeliveryRequest (**data: Any)-
Expand source code
class ValidateContentDeliveryRequest(AdCPBaseModel): context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None feature_ids: Annotated[ list[str] | None, Field(description='Specific features to evaluate (defaults to all)', min_length=1), ] = None include_passed: Annotated[ bool | None, Field(description='Include passed records in results') ] = True records: Annotated[ list[Record], Field( description='Delivery records to validate (max 10,000)', max_length=10000, min_length=1 ), ] standards_id: Annotated[str, Field(description='Standards configuration to validate against')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar feature_ids : list[str] | Nonevar include_passed : bool | Nonevar model_configvar records : list[Record]var standards_id : str
Inherited members
class ValidateContentDeliverySuccessResponse (**data: Any)-
Expand source code
class ValidateContentDeliveryResponse1(AdCPBaseModel): context: context_1.ContextObject | None = None ext: ext_1.ExtensionObject | None = None results: Annotated[list[Result], Field(description='Per-record evaluation results')] summary: Annotated[Summary, Field(description='Summary counts across all records')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar model_configvar results : list[Result]var summary : Summary
Inherited members
class ValidateContentDeliveryErrorResponse (**data: Any)-
Expand source code
class ValidateContentDeliveryResponse2(AdCPBaseModel): context: context_1.ContextObject | None = None errors: list[error.Error] ext: ext_1.ExtensionObject | None = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var context : ContextObject | Nonevar errors : list[Error]var ext : ExtensionObject | Nonevar model_config
Inherited members
class ValidationMode (*args, **kwds)-
Expand source code
class ValidationMode(Enum): strict = 'strict' lenient = 'lenient'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var lenientvar strict
class UrlVastAsset (**data: Any)-
Expand source code
class VastAsset1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = None captions_url: Annotated[ AnyUrl | None, Field(description='URL to captions file (WebVTT, SRT, etc.)') ] = None delivery_type: Annotated[ Literal['url'], Field(description='Discriminator indicating VAST is delivered via URL endpoint'), ] duration_ms: Annotated[ int | None, Field(description='Expected video duration in milliseconds (if known)', ge=0) ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None tracking_events: Annotated[ list[vast_tracking_event.VastTrackingEvent] | None, Field(description='Tracking events supported by this VAST tag'), ] = None url: Annotated[AnyUrl, Field(description='URL endpoint that returns VAST XML')] vast_version: Annotated[ vast_version_1.VastVersion | None, Field(description='VAST specification version') ] = None vpaid_enabled: Annotated[ bool | None, Field(description='Whether VPAID (Video Player-Ad Interface Definition) is supported'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var audio_description_url : pydantic.networks.AnyUrl | Nonevar captions_url : pydantic.networks.AnyUrl | Nonevar delivery_type : Literal['url']var duration_ms : int | Nonevar model_configvar provenance : Provenance | Nonevar tracking_events : list[VastTrackingEvent] | Nonevar url : pydantic.networks.AnyUrlvar vast_version : VastVersion | Nonevar vpaid_enabled : bool | None
Inherited members
class InlineVastAsset (**data: Any)-
Expand source code
class VastAsset2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = None captions_url: Annotated[ AnyUrl | None, Field(description='URL to captions file (WebVTT, SRT, etc.)') ] = None content: Annotated[str, Field(description='Inline VAST XML content')] delivery_type: Annotated[ Literal['inline'], Field(description='Discriminator indicating VAST is delivered as inline XML content'), ] duration_ms: Annotated[ int | None, Field(description='Expected video duration in milliseconds (if known)', ge=0) ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None tracking_events: Annotated[ list[vast_tracking_event.VastTrackingEvent] | None, Field(description='Tracking events supported by this VAST tag'), ] = None vast_version: Annotated[ vast_version_1.VastVersion | None, Field(description='VAST specification version') ] = None vpaid_enabled: Annotated[ bool | None, Field(description='Whether VPAID (Video Player-Ad Interface Definition) is supported'), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var audio_description_url : pydantic.networks.AnyUrl | Nonevar captions_url : pydantic.networks.AnyUrl | Nonevar content : strvar delivery_type : Literal['inline']var duration_ms : int | Nonevar model_configvar provenance : Provenance | Nonevar tracking_events : list[VastTrackingEvent] | Nonevar vast_version : VastVersion | Nonevar vpaid_enabled : bool | None
Inherited members
class VastTrackingEvent (*args, **kwds)-
Expand source code
class VastTrackingEvent(Enum): start = 'start' firstQuartile = 'firstQuartile' midpoint = 'midpoint' thirdQuartile = 'thirdQuartile' complete = 'complete' impression = 'impression' click = 'click' pause = 'pause' resume = 'resume' skip = 'skip' mute = 'mute' unmute = 'unmute' fullscreen = 'fullscreen' exitFullscreen = 'exitFullscreen' playerExpand = 'playerExpand' playerCollapse = 'playerCollapse'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var clickvar completevar exitFullscreenvar firstQuartilevar fullscreenvar impressionvar midpointvar mutevar pausevar playerCollapsevar playerExpandvar resumevar skipvar startvar thirdQuartilevar unmute
class TrackingEvent (*args, **kwds)-
Expand source code
class VastTrackingEvent(Enum): start = 'start' firstQuartile = 'firstQuartile' midpoint = 'midpoint' thirdQuartile = 'thirdQuartile' complete = 'complete' impression = 'impression' click = 'click' pause = 'pause' resume = 'resume' skip = 'skip' mute = 'mute' unmute = 'unmute' fullscreen = 'fullscreen' exitFullscreen = 'exitFullscreen' playerExpand = 'playerExpand' playerCollapse = 'playerCollapse'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var clickvar completevar exitFullscreenvar firstQuartilevar fullscreenvar impressionvar midpointvar mutevar pausevar playerCollapsevar playerExpandvar resumevar skipvar startvar thirdQuartilevar unmute
class VastVersion (*args, **kwds)-
Expand source code
class VastVersion(Enum): field_2_0 = '2.0' field_3_0 = '3.0' field_4_0 = '4.0' field_4_1 = '4.1' field_4_2 = '4.2'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var field_2_0var field_3_0var field_4_0var field_4_1var field_4_2
class VcpmPricingOption (**data: Any)-
Expand source code
class VcpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['vcpm']var pricing_option_id : str
class VcpmAuctionPricingOption (**data: Any)-
Expand source code
class VcpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['vcpm']var pricing_option_id : str
class VcpmFixedRatePricingOption (**data: Any)-
Expand source code
class VcpmPricingOption(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] eligible_adjustments: Annotated[ list[adjustment_kind.PriceAdjustmentKind] | None, Field( description='Adjustment kinds applicable to this pricing option. Tells buyer agents which adjustments are available before negotiation. When absent, no adjustments are pre-declared — the buyer should check price_breakdown if present.' ), ] = None fixed_price: Annotated[ float | None, Field( description='Fixed price per unit. If present, this is fixed pricing. If absent, auction-based.', ge=0.0, ), ] = None floor_price: Annotated[ float | None, Field( description='Minimum acceptable bid for auction pricing (mutually exclusive with fixed_price). Bids below this value will be rejected.', ge=0.0, ), ] = None max_bid: Annotated[ bool | None, Field( description="When true, bid_price is interpreted as the buyer's maximum willingness to pay (ceiling) rather than an exact price. Sellers may optimize actual clearing prices between floor_price and bid_price based on delivery pacing. When false or absent, bid_price (if provided) is the exact bid/price to honor." ), ] = False min_spend_per_package: Annotated[ float | None, Field( description='Minimum spend requirement per package using this pricing option, in the specified currency', ge=0.0, ), ] = None price_breakdown: Annotated[ price_breakdown_1.PriceBreakdown | None, Field( description='Breakdown of how fixed_price was derived from the list (rate card) price. Only meaningful when fixed_price is present.' ), ] = None price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var currency : strvar eligible_adjustments : list[PriceAdjustmentKind] | Nonevar fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar price_breakdown : PriceBreakdown | Nonevar price_guidance : PriceGuidance | Nonevar pricing_model : Literal['vcpm']var pricing_option_id : str
Inherited members
class VenueBreakdownItem (**data: Any)-
Expand source code
class VenueBreakdownItem(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) impressions: Annotated[int, Field(description='Impressions delivered at this venue', ge=0)] loop_plays: Annotated[int | None, Field(description='Loop plays at this venue', ge=0)] = None screens_used: Annotated[ int | None, Field(description='Number of screens used at this venue', ge=0) ] = None venue_id: Annotated[str, Field(description='Venue identifier')] venue_name: Annotated[str | None, Field(description='Human-readable venue name')] = None venue_type: Annotated[ str | None, Field(description="Venue type (e.g., 'airport', 'transit', 'retail', 'billboard')"), ] = NoneBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var impressions : intvar loop_plays : int | Nonevar model_configvar screens_used : int | Nonevar venue_id : strvar venue_name : str | Nonevar venue_type : str | None
Inherited members
class VideoAsset (**data: Any)-
Expand source code
class VideoAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) audio_bit_depth: Annotated[AudioBitDepth | None, Field(description='Audio bit depth')] = None audio_bitrate_kbps: Annotated[ int | None, Field(description='Audio bitrate in kilobits per second', ge=1) ] = None audio_channels: Annotated[ AudioChannels | None, Field(description='Audio channel configuration') ] = None audio_codec: Annotated[ str | None, Field(description='Audio codec used (aac, aac_lc, he_aac, pcm, mp3, ac3, eac3, etc.)'), ] = None audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = None audio_loudness_lufs: Annotated[ float | None, Field(description='Integrated loudness in LUFS') ] = None audio_sampling_rate_hz: Annotated[ int | None, Field(description='Audio sampling rate in Hz (e.g., 44100, 48000)') ] = None audio_true_peak_dbfs: Annotated[float | None, Field(description='True peak level in dBFS')] = ( None ) captions_url: Annotated[ AnyUrl | None, Field(description='URL to captions file (WebVTT, SRT, etc.)') ] = None chroma_subsampling: Annotated[ ChromaSubsampling | None, Field(description='Chroma subsampling format') ] = None color_space: Annotated[ColorSpace | None, Field(description='Color space of the video')] = None container_format: Annotated[ str | None, Field(description='Video container format (mp4, webm, mov, etc.)') ] = None duration_ms: Annotated[ int | None, Field(description='Video duration in milliseconds', ge=1) ] = None file_size_bytes: Annotated[int | None, Field(description='File size in bytes', ge=1)] = None frame_rate: Annotated[ str | None, Field( description="Frame rate as string to preserve precision (e.g., '23.976', '29.97', '30')" ), ] = None frame_rate_type: Annotated[ FrameRateType | None, Field(description='Whether the video uses constant (CFR) or variable (VFR) frame rate'), ] = None gop_interval_seconds: Annotated[ float | None, Field(description='GOP/keyframe interval in seconds') ] = None gop_type: Annotated[GopType | None, Field(description='GOP structure type')] = None has_audio: Annotated[ bool | None, Field(description='Whether the video contains an audio track') ] = None hdr_format: Annotated[ HdrFormat | None, Field(description="HDR format if applicable, or 'sdr' for standard dynamic range"), ] = None height: Annotated[int, Field(description='Height in pixels', ge=1)] moov_atom_position: Annotated[ MoovAtomPosition | None, Field(description='Position of moov atom in MP4 container') ] = None provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None scan_type: Annotated[ScanType | None, Field(description='Scan type of the video')] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the video content') ] = None url: Annotated[AnyUrl, Field(description='URL to the video asset')] video_bit_depth: Annotated[VideoBitDepth | None, Field(description='Video bit depth')] = None video_bitrate_kbps: Annotated[ int | None, Field(description='Video stream bitrate in kilobits per second', ge=1) ] = None video_codec: Annotated[ str | None, Field(description='Video codec used (h264, h265, vp9, av1, prores, etc.)') ] = None width: Annotated[int, Field(description='Width in pixels', ge=1)]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var audio_bit_depth : AudioBitDepth | Nonevar audio_bitrate_kbps : int | Nonevar audio_channels : AudioChannels | Nonevar audio_codec : str | Nonevar audio_description_url : pydantic.networks.AnyUrl | Nonevar audio_loudness_lufs : float | Nonevar audio_sampling_rate_hz : int | Nonevar audio_true_peak_dbfs : float | Nonevar captions_url : pydantic.networks.AnyUrl | Nonevar chroma_subsampling : ChromaSubsampling | Nonevar color_space : ColorSpace | Nonevar container_format : str | Nonevar duration_ms : int | Nonevar file_size_bytes : int | Nonevar frame_rate : str | Nonevar frame_rate_type : FrameRateType | Nonevar gop_interval_seconds : float | Nonevar gop_type : GopType | Nonevar has_audio : bool | Nonevar hdr_format : HdrFormat | Nonevar height : intvar model_configvar moov_atom_position : MoovAtomPosition | Nonevar provenance : Provenance | Nonevar scan_type : ScanType | Nonevar transcript_url : pydantic.networks.AnyUrl | Nonevar url : pydantic.networks.AnyUrlvar video_bit_depth : VideoBitDepth | Nonevar video_bitrate_kbps : int | Nonevar video_codec : str | Nonevar width : int
Inherited members
class ViewThreshold (root: RootModelRootType = PydanticUndefined, **data)-
Expand source code
class ViewThreshold(RootModel[float]): root: Annotated[ float, Field( description='Percentage completion threshold (0.0 to 1.0, e.g., 0.5 = 50%)', ge=0.0, le=1.0, ), ]Usage Documentation
A Pydantic
BaseModelfor 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.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.root_model.RootModel[float]
- pydantic.root_model.RootModel
- pydantic.main.BaseModel
- typing.Generic
Class variables
var model_configvar root : float
class WcagLevel (*args, **kwds)-
Expand source code
class WcagLevel(Enum): A = 'A' AA = 'AA' AAA = 'AAA'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var Avar AAvar AAA
class WebhookAsset (**data: Any)-
Expand source code
class WebhookAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) method: Annotated[http_method.HttpMethod | None, Field(description='HTTP method')] = ( http_method.HttpMethod.POST ) provenance: Annotated[ provenance_1.Provenance | None, Field( description='Provenance metadata for this asset, overrides manifest-level provenance' ), ] = None required_macros: Annotated[ list[universal_macro.UniversalMacro | str] | None, Field(description='Universal macros that must be provided for webhook to function'), ] = None response_type: Annotated[ webhook_response_type.WebhookResponseType, Field(description='Expected content type of webhook response'), ] security: Annotated[Security, Field(description='Security configuration for webhook calls')] supported_macros: Annotated[ list[universal_macro.UniversalMacro | str] | None, Field( description='Universal macros that can be passed to webhook (e.g., DEVICE_TYPE, COUNTRY). See docs/creative/universal-macros.mdx for full list.' ), ] = None timeout_ms: Annotated[ int | None, Field(description='Maximum time to wait for response in milliseconds', ge=10, le=5000), ] = 500 url: Annotated[AnyUrl, Field(description='Webhook URL to call for dynamic content')]Base model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- AdCPBaseModel
- pydantic.main.BaseModel
Class variables
var method : HttpMethod | Nonevar model_configvar provenance : Provenance | Nonevar required_macros : list[UniversalMacro | str] | Nonevar response_type : WebhookResponseTypevar security : Securityvar supported_macros : list[UniversalMacro | str] | Nonevar timeout_ms : int | Nonevar url : pydantic.networks.AnyUrl
Inherited members
class WebhookMetadata (**data: Any)-
Expand source code
class WebhookMetadata(BaseModel): """Metadata passed to webhook handlers.""" operation_id: str agent_id: str task_type: str status: TaskStatus sequence_number: int | None = None notification_type: Literal["scheduled", "final", "delayed"] | None = None timestamp: strMetadata passed to webhook handlers.
Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.selfis explicitly positional-only to allowselfas a field name.Ancestors
- pydantic.main.BaseModel
Class variables
var agent_id : strvar model_configvar notification_type : Literal['scheduled', 'final', 'delayed'] | Nonevar operation_id : strvar sequence_number : int | Nonevar status : TaskStatusvar task_type : strvar timestamp : str
class WebhookResponseType (*args, **kwds)-
Expand source code
class WebhookResponseType(Enum): html = 'html' json = 'json' xml = 'xml' javascript = 'javascript'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var htmlvar javascriptvar jsonvar xml
class ResponseType (*args, **kwds)-
Expand source code
class WebhookResponseType(Enum): html = 'html' json = 'json' xml = 'xml' javascript = 'javascript'Create a collection of name/value pairs.
Example enumeration:
>>> class Color(Enum): ... RED = 1 ... BLUE = 2 ... GREEN = 3Access them by:
- attribute access::
>>> Color.RED <Color.RED: 1>- value lookup:
>>> Color(1) <Color.RED: 1>- name lookup:
>>> Color['RED'] <Color.RED: 1>Enumerations can be iterated over, and know how many members they have:
>>> len(Color) 3>>> list(Color) [<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.
Ancestors
- enum.Enum
Class variables
var htmlvar javascriptvar jsonvar xml