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!
ListCreativeFormatsRequest(type=FormatCategory.video) # Also 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_poc
Classes
class A2UiComponent (**data: Any)-
Expand source code
class A2UiComponent(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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)') ] = None component: Annotated[ dict[str, dict[str, Any]], Field(description='Component definition (keyed by 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 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', ) surfaceId: Annotated[str, Field(description='Unique identifier for this surface')] 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)'), ] rootId: Annotated[ str | None, Field(description='ID of the root component (if not specified, first component is root)'), ] = None dataModel: Annotated[ dict[str, Any] | None, Field(description='Application data that components can bind to') ] = 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 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', ) 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])?)*$', ), ] 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. The seller must either accept this billing model or reject the request.' ), ] 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.' ), ] = None governance_agents: Annotated[ list[GovernanceAgent] | None, Field( description='Governance agent endpoints for this account. When present, the seller MUST call these agents for governance approval before confirming media buy requests. Each agent can be scoped to specific validation categories. The seller routes check_governance calls to the appropriate agent based on the action being validated. All applicable agents must approve for the action to proceed (unanimous approval).', 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 billing : Billingvar brand : BrandReferencevar governance_agents : list[GovernanceAgent] | Nonevar 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': {'domain': 'nova-brands.com', 'brand_id': 'spark'}, '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 ActivateSignalRequest (**data: Any)-
Expand source code
class ActivateSignalRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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 signal_agent_segment_id: Annotated[ str, Field(description='The universal identifier for the signal to activate') ] 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, ), ] 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 account: Annotated[ account_ref.AccountReference | None, Field( description='Account for this activation. Associates with a commercial relationship established via sync_accounts.' ), ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="The buyer's campaign reference for this activation. Enables the signals agent to correlate activations with subsequent report_usage calls." ), ] = None 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 account : AccountReference | Nonevar action : Action | Nonevar buyer_campaign_ref : str | Nonevar context : ContextObject | Nonevar destinations : list[Destination]var ext : ExtensionObject | 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', ) deployments: Annotated[ list[deployment.Deployment], Field(description='Array of deployment results for each deployment target'), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) 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, ), ] 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 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', ) type: Annotated[Literal['segment_id'], Field(description='Segment ID based targeting')] segment_id: Annotated[ str, Field(description='The platform-specific segment identifier to use in campaign 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', ) type: Annotated[Literal['segment_id'], Field(description='Segment ID based targeting')] segment_id: Annotated[ str, Field(description='The platform-specific segment identifier to use in campaign 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', ) type: Annotated[Literal['key_value'], Field(description='Key-value pair based targeting')] key: Annotated[str, Field(description='The targeting parameter key')] 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', ) type: Annotated[Literal['key_value'], Field(description='Key-value pair based targeting')] key: Annotated[str, Field(description='The targeting parameter key')] 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', ) impressions: Annotated[ float, Field(description='Total impressions delivered across all media buys', ge=0.0) ] spend: Annotated[float, Field(description='Total amount spent across all media buys', ge=0.0)] clicks: Annotated[ float | None, Field(description='Total clicks across all media buys (if applicable)', ge=0.0), ] = None video_completions: Annotated[ float | None, Field(description='Total video completions 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 conversion_value: Annotated[ float | None, Field(description='Total conversion value across all media buys (if applicable)', ge=0.0), ] = 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 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 cost_per_acquisition: Annotated[ float | None, Field( description='Aggregate cost per conversion across all media buys (total spend / total conversions)', ge=0.0, ), ] = None media_buy_count: Annotated[ int, Field(description='Number of media buys included in the response', 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 clicks : float | Nonevar conversion_value : float | Nonevar conversions : float | Nonevar cost_per_acquisition : float | Nonevar impressions : floatvar media_buy_count : intvar model_configvar new_to_brand_rate : float | Nonevar roas : float | Nonevar spend : floatvar video_completions : float | None
Inherited members
class Artifact (**data: Any)-
Expand source code
class Artifact(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) property_id: Annotated[ identifier.Identifier, Field(description='Identifier for the property where this artifact appears'), ] 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')." ), ] 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." ), ] = None 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 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 published_time: Annotated[ AwareDatetime | None, Field(description='When the artifact was published (ISO 8601 format)') ] = None last_update_time: Annotated[ AwareDatetime | None, Field(description='When the artifact was last modified (ISO 8601 format)'), ] = None assets: Annotated[ list[Assets | Assets1 | Assets2 | Assets3], Field( description='Artifact assets in document flow order - text blocks, images, video, audio' ), ] metadata: Annotated[ Metadata | None, Field(description='Rich metadata extracted from the artifact') ] = None 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 identifiers: Annotated[ Identifiers | None, Field(description='Platform-specific identifiers for this artifact') ] = 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_id : Identifiervar 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', ) media_buy_id: Annotated[ str, Field(description='Media buy identifier these artifacts belong to') ] batch_id: Annotated[ str, Field( description='Unique identifier for this batch of artifacts. Use for deduplication and acknowledgment.' ), ] timestamp: Annotated[ AwareDatetime, Field(description='When this batch was generated (ISO 8601)') ] artifacts: Annotated[ list[Artifact], Field(description='Content artifacts from delivered impressions') ] pagination: Annotated[ Pagination | None, Field(description='Pagination info when batching large artifact sets') ] = 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 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') ] url: Annotated[AnyUrl, Field(description='URL to CDN-hosted asset file')] tags: Annotated[list[str] | None, Field(description='Tags for discovery')] = None name: Annotated[str | None, Field(description='Human-readable name')] = None description: Annotated[str | None, Field(description='Asset description or usage notes')] = None width: Annotated[int | None, Field(description='Image/video width in pixels')] = None height: Annotated[int | None, Field(description='Image/video height in pixels')] = 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')")] = 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 AssetSelectors (**data: Any)-
Expand source code
class AssetSelectors(_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 AssignedPackage (**data: Any)-
Expand source code
class AssignedPackage(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) package_id: Annotated[str, Field(description='Package identifier')] buyer_ref: Annotated[ str | None, Field(description="Buyer's reference identifier for this package") ] = None assigned_date: Annotated[AwareDatetime, Field(description='When this assignment was created')]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 buyer_ref : str | Nonevar model_configvar package_id : str
Inherited members
class Assignments (**data: Any)-
Expand source code
class Assignments(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) assignment_count: Annotated[ int, Field(description='Total number of active package assignments', ge=0) ] assigned_packages: Annotated[ list[AssignedPackage] | None, Field(description='List of packages this creative is assigned to'), ] = 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 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', ) audience_id: Annotated[ str, Field( description="Buyer's identifier for this audience. Used to reference the audience in targeting overlays." ), ] name: Annotated[str | None, Field(description='Human-readable name for this audience')] = 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 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 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." ), ] = None 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 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 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 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.' ), ] = 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', ) url: Annotated[AnyUrl, Field(description='URL to the audio asset')] 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 container_format: Annotated[ str | None, Field(description='Audio container/file format (mp3, m4a, aac, wav, ogg, flac, etc.)'), ] = None codec: Annotated[ str | None, Field( description='Audio codec used (aac, aac_lc, he_aac, pcm, mp3, vorbis, opus, flac, ac3, eac3, etc.)' ), ] = None sampling_rate_hz: Annotated[ int | None, Field(description='Sampling rate in Hz (e.g., 44100, 48000, 96000)') ] = None channels: Annotated[Channels | None, Field(description='Channel configuration')] = None 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 loudness_lufs: Annotated[float | None, Field(description='Integrated loudness in LUFS')] = None true_peak_dbfs: Annotated[float | None, Field(description='True peak level in dBFS')] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = 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 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', ) schemes: Annotated[list[auth_scheme.AuthenticationScheme], Field(max_length=1, min_length=1)] credentials: Annotated[ str, Field(description='Authentication credential (e.g., Bearer token).', min_length=32) ]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', ) url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['property_ids'], Field(description='Discriminator indicating authorization by specific property IDs'), ] 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, ), ]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 url : pydantic.networks.AnyUrl
class AuthorizedAgentsByPropertyId (**data: Any)-
Expand source code
class AuthorizedAgents(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['property_ids'], Field(description='Discriminator indicating authorization by specific property IDs'), ] 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, ), ]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 url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByPropertyTag (**data: Any)-
Expand source code
class AuthorizedAgents1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['property_tags'], Field(description='Discriminator indicating authorization by property tags'), ] 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, ), ]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 url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByInlineProperties (**data: Any)-
Expand source code
class AuthorizedAgents2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['inline_properties'], Field(description='Discriminator indicating authorization by inline property definitions'), ] properties: Annotated[ list[property.Property], Field( description='Specific properties this agent is authorized for (alternative to property_ids/property_tags)', 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 properties : list[Property]var url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsByPublisherProperties (**data: Any)-
Expand source code
class AuthorizedAgents3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what this agent is authorized to sell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['publisher_properties'], Field( description='Discriminator indicating authorization for properties from other publisher domains' ), ] 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, ), ]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_properties : list[PublisherPropertySelector]var url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsBySignalId (**data: Any)-
Expand source code
class AuthorizedAgents4(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what signals this agent is authorized to resell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['signal_ids'], Field(description='Discriminator indicating authorization by specific signal IDs'), ] 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, ), ]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 url : pydantic.networks.AnyUrl
Inherited members
class AuthorizedAgentsBySignalTag (**data: Any)-
Expand source code
class AuthorizedAgents5(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description="The authorized signals agent's API endpoint URL")] authorized_for: Annotated[ str, Field( description='Human-readable description of what signals this agent is authorized to resell', max_length=500, min_length=1, ), ] authorization_type: Annotated[ Literal['signal_tags'], Field(description='Discriminator indicating authorization by signal tags'), ] 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, ), ]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 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 BrandManifest (**data: Any)-
Expand source code
class BrandManifest(_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 BrandReference (**data: Any)-
Expand source code
class BrandReference(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) domain: Annotated[ str, Field( description="Domain where /.well-known/brand.json is hosted, or the brand's operating domain", pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$', ), ] brand_id: Annotated[ brand_id_1.BrandId | None, Field( description='Brand identifier within the house portfolio. Optional for single-brand domains.' ), ] = 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 : BrandId | Nonevar domain : strvar model_config
Inherited members
class BuildCreativeSuccessResponse (**data: Any)-
Expand source code
class BuildCreativeResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='The generated or transformed creative manifest'), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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 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 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', ) 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, ), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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 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 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): package_id: Annotated[str, Field(description="Publisher's package identifier")] buyer_ref: Annotated[ str | None, Field(description="Buyer's reference identifier for this package") ] = None pacing_index: Annotated[ float | None, Field(description='Delivery pace (1.0 = on track, <1.0 = behind, >1.0 = ahead)', ge=0.0), ] = 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, ), ] 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}$', ), ] delivery_status: Annotated[ DeliveryStatus | None, Field( description='System-reported operational state of this package. Reflects actual delivery state independent of buyer pause control.' ), ] = None paused: Annotated[ bool | None, Field(description='Whether this package is currently paused by the buyer') ] = 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_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_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_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_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_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_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 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 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 buyer_ref : str | Nonevar 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): standards_id: Annotated[str, Field(description='Standards configuration to calibrate against')] artifact: Annotated[artifact_1.Artifact, Field(description='Artifact to evaluate')]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 model_configvar standards_id : str
Inherited members
class CalibrateContentSuccessResponse (**data: Any)-
Expand source code
class CalibrateContentResponse1(AdCPBaseModel): verdict: Annotated[ Verdict, Field(description='Overall pass/fail verdict for the content evaluation') ] confidence: Annotated[ float | None, Field(description='Model confidence in the verdict (0-1)', ge=0.0, le=1.0) ] = None explanation: Annotated[ str | None, Field(description='Detailed natural language explanation of the decision') ] = None features: Annotated[ list[Feature] | None, Field(description='Per-feature breakdown with explanations') ] = None 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 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): errors: list[error.Error] 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 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 name: Annotated[ str | None, Field( description="Human-readable name for this catalog (e.g., 'Summer Products 2025', 'Amsterdam Store Locations')." ), ] = 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." ), ] 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." ), ] = 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 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 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 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 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 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 category: Annotated[ str | None, Field( description="Filter catalog to items in this category (e.g., 'beverages/soft-drinks', 'chef-positions')." ), ] = None query: Annotated[ str | None, Field( description="Natural language filter for catalog items (e.g., 'all pasta sauces under $5', 'amsterdam vacancies')." ), ] = 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 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 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, ), ] = 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', ) catalog_id: Annotated[str, Field(description='Catalog ID from the request')] action: Annotated[ catalog_action.CatalogAction, Field(description='Action taken for this catalog') ] platform_id: Annotated[ str | None, Field(description='Platform-specific ID assigned to the catalog') ] = None item_count: Annotated[ int | None, Field(description='Total number of items in the catalog after sync', ge=0) ] = 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 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 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 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 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=[ { 'description': 'Scalar binding — hotel name to headline slot', 'data': {'kind': 'scalar', 'asset_id': 'headline', 'catalog_field': 'name'}, }, { 'description': 'Scalar binding — nested field (nightly rate)', 'data': { 'kind': 'scalar', 'asset_id': 'price_badge', 'catalog_field': 'price.amount', }, }, { 'description': 'Asset pool binding — hero image from landscape pool', 'data': { 'kind': 'asset_pool', 'asset_id': 'hero_image', 'asset_group_id': 'images_landscape', }, }, { 'description': 'Asset pool binding — Snap vertical background from vertical pool', 'data': { 'kind': 'asset_pool', 'asset_id': 'snap_background', 'asset_group_id': 'images_vertical', }, }, { 'description': 'Catalog group binding — carousel where each slide is one hotel', 'data': { 'kind': 'catalog_group', 'format_group_id': 'slide', 'catalog_item': True, 'per_item_bindings': [ {'kind': 'scalar', 'asset_id': 'title', 'catalog_field': 'name'}, { 'kind': 'scalar', 'asset_id': 'price', 'catalog_field': 'price.amount', }, { 'kind': 'asset_pool', 'asset_id': 'image', 'asset_group_id': 'images_landscape', }, ], }, }, ], 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', ) kind: Literal['catalog_group'] format_group_id: Annotated[ str, Field(description="The asset_group_id of a repeatable_group in the format's assets array."), ] catalog_item: Annotated[ Literal[True], Field( description="Each repetition of the format's repeatable_group maps to one item from the catalog." ), ] 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, ), ] = 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 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', ) kind: Literal['catalog_group'] format_group_id: Annotated[ str, Field(description="The asset_group_id of a repeatable_group in the format's assets array."), ] catalog_item: Annotated[ Literal[True], Field( description="Each repetition of the format's repeatable_group maps to one item from the catalog." ), ] 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, ), ] = 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 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', ) 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 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 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 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).' ), ] = 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 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 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 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 separator: Annotated[ str | None, Field( description="For transform 'split': the separator character or string to split on. Defaults to ','." ), ] = ',' 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 = 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'), ] 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 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 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 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, ), ] = None 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 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 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, ), ] = 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', ) plan_id: Annotated[str, Field(description='Campaign governance plan identifier.')] buyer_campaign_ref: Annotated[ str, Field( description="Buyer's campaign identifier. The governance agent tracks state per campaign within a plan." ), ] binding: Annotated[ Binding, Field( description="Whether this is an advisory check or a binding commitment. 'proposed': the orchestrator is checking before sending to a seller — no budget is committed. 'committed': the seller is about to execute — the governance agent validates the planned delivery against the plan. Budget is committed later via report_plan_outcome, not on approval." ), ] caller: Annotated[ AnyUrl, Field( description='URL of the agent making the request (orchestrator for proposed, seller for committed).' ), ] tool: Annotated[ str | None, Field( description="The AdCP tool being checked (e.g., 'create_media_buy', 'get_products'). Expected for proposed checks. The governance agent uses this to apply tool-specific validation rules." ), ] = None payload: Annotated[ dict[str, Any] | None, Field( description='The full tool arguments as they would be sent to the seller. Expected for proposed checks. The governance agent can inspect any field to validate against the plan.' ), ] = None governance_context: Annotated[ governance_context_1.GovernanceContext | None, Field( description='Normalized governance-relevant fields extracted from the tool payload. When present, the governance agent SHOULD use these fields for plan validation instead of parsing the payload directly. The caller is responsible for extracting these from the tool arguments.' ), ] = None media_buy_id: Annotated[ str | None, Field( description="The seller's identifier for the media buy. Expected for committed checks." ), ] = None buyer_ref: Annotated[ str | None, Field(description="The buyer's reference identifier from the create_media_buy request."), ] = 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 planned_delivery: Annotated[ planned_delivery_1.PlannedDelivery | None, Field( description="What the seller will actually deliver. For committed checks, this is the seller's interpreted delivery parameters. For proposed checks, the orchestrator may include this if it has computed delivery expectations." ), ] = None 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 modification_summary: Annotated[ str | None, Field( description="Human-readable summary of what changed. SHOULD be present for 'modification' phase." ), ] = 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 binding : Bindingvar buyer_campaign_ref : strvar buyer_ref : str | Nonevar caller : pydantic.networks.AnyUrlvar delivery_metrics : DeliveryMetrics | Nonevar governance_context : GovernanceContext | 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', ) 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.' ), ] 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. 'escalated': halted pending human review." ), ] binding: Annotated[ Binding, Field( description='Echoed from request. Lets the caller confirm the governance agent understood the commitment level.' ), ] plan_id: Annotated[str, Field(description='Echoed from request.')] buyer_campaign_ref: Annotated[str, Field(description='Echoed from request.')] explanation: Annotated[ str, Field(description='Human-readable explanation of the governance decision.') ] mode: Annotated[ governance_mode.GovernanceMode | None, Field( description="The governance mode under which this check was evaluated. Present so audit trails can distinguish 'denied in advisory mode (action proceeded)' from 'denied in enforce mode (action blocked)'." ), ] = None findings: Annotated[ list[Finding] | None, Field( description="Specific issues found during the governance check. Present when status is 'denied', 'conditions', or 'escalated'. MAY also be present on 'approved' for advisory findings (e.g., budget approaching limit)." ), ] = None 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 escalation: Annotated[ Escalation | None, Field( description="Present when status is 'escalated'. The action is halted pending human review." ), ] = 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 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 categories_evaluated: Annotated[ list[str] | None, Field(description='Governance categories evaluated during this check.') ] = None policies_evaluated: Annotated[ list[str] | None, Field(description='Registry policy IDs evaluated during this 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 binding : Bindingvar buyer_campaign_ref : strvar categories_evaluated : list[str] | Nonevar check_id : strvar conditions : list[Condition] | Nonevar escalation : Escalation | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar explanation : strvar findings : list[Finding] | Nonevar mode : GovernanceMode | 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', ) primary: Primary | Primary1 | None = None secondary: Secondary | Secondary1 | None = None accent: Accent | Accent1 | None = None background: Background2 | Background3 | 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 : Background2 | Background3 | Nonevar model_configvar primary : Primary | Primary1 | Nonevar secondary : Secondary | Secondary1 | Nonevar text : Text | Text1 | None
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', ) 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, ), ] email: Annotated[ EmailStr | None, Field( description='Contact email for questions or issues with this authorization file', max_length=255, min_length=1, ), ] = None 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 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, ), ] = None 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." ), ] = 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): standards_id: Annotated[ str, Field(description='Unique identifier for this standards configuration') ] name: Annotated[ str | None, Field(description='Human-readable name for this standards configuration') ] = 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 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 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 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 calibration_exemplars: Annotated[ CalibrationExemplars | None, Field( description='Training/test set to calibrate policy interpretation. Provides concrete examples of pass/fail decisions.' ), ] = 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 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
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 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['cpa'], Field(description='Cost per acquisition (conversion event)') ] event_type: Annotated[ event_type_1.EventType, Field( description='The conversion event type that triggers billing (e.g., purchase, lead, app_install)' ), ] 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 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 currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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, ), ] = 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 custom_event_name : str | Nonevar event_source_id : str | Nonevar event_type : EventTypevar fixed_price : floatvar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpc'], Field(description='Cost per click')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['cpcv'], Field(description='Cost per completed view (100% completion)') ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpm'], Field(description='Cost per 1,000 impressions')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpp'], Field(description='Cost per Gross Rating Point')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None parameters: Annotated[ Parameters, Field(description='CPP-specific parameters for demographic targeting') ] 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[Literal['cpv'], Field(description='Cost per view at threshold')] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None parameters: Annotated[ Parameters, Field(description='CPV-specific parameters defining the view threshold') ] 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar 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', ) scope: Annotated[Scope, Field(description='Where this standards configuration applies')] 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 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.' ), ] 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 = 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 calibration_exemplars : CalibrationExemplars | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | 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): standards_id: Annotated[ str, Field(description='Unique identifier for the created standards configuration') ] 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_configvar standards_id : str
Inherited members
class CreateContentStandardsErrorResponse (**data: Any)-
Expand source code
class CreateContentStandardsResponse2(AdCPBaseModel): errors: list[error.Error] 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 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', ) buyer_ref: Annotated[ str, Field( description="Buyer's reference identifier for this media buy. Sellers SHOULD deduplicate requests with the same buyer_ref and account, returning the existing media buy rather than creating a duplicate." ), ] buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label. Groups related discovery and buy operations under a single campaign for CRM and ad server correlation (e.g., 'NovaDrink_Meals_Q2')." ), ] = 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 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.' ), ] 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 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." ), ] = 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 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.' ), ] po_number: Annotated[str | None, Field(description='Purchase order number for tracking')] = None start_time: start_timing.StartTiming end_time: Annotated[ AwareDatetime, Field(description='Campaign end date/time in ISO 8601 format') ] 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 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 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 account : AccountReferencevar artifact_webhook : ArtifactWebhook | Nonevar brand : BrandReferencevar buyer_campaign_ref : str | Nonevar buyer_ref : strvar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetimevar ext : ExtensionObject | 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', ) media_buy_id: Annotated[ str, Field(description="Publisher's unique identifier for the created media buy") ] buyer_ref: Annotated[str, Field(description="Buyer's reference identifier for this media buy")] buyer_campaign_ref: Annotated[ str | None, Field(description="Buyer's campaign reference label, echoed from the request") ] = None 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 creative_deadline: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp for creative upload deadline') ] = None 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 sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 account : Account | Nonevar buyer_campaign_ref : str | Nonevar buyer_ref : strvar context : ContextObject | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar packages : list[Package]var planned_delivery : PlannedDelivery | Nonevar sandbox : bool | None
Inherited members
class CreateMediaBuyErrorResponse (**data: Any)-
Expand source code
class CreateMediaBuyResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) errors: Annotated[ list[error.Error], Field(description='Array of errors explaining why the operation failed', min_length=1), ] 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 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', ) name: Annotated[str, Field(description='Human-readable name for the list')] description: Annotated[str | None, Field(description="Description of the list's purpose")] = ( None ) 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 filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Dynamic filters to apply when resolving the list'), ] = 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 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 base_properties : list[BasePropertySource] | Nonevar brand : BrandReference | Nonevar context : ContextObject | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar filters : PropertyListFilters | Nonevar model_configvar name : str
Inherited members
class CreatePropertyListResponse (**data: Any)-
Expand source code
class CreatePropertyListResponse(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) list: Annotated[property_list.PropertyList, Field(description='The created property list')] 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 = 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 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')] 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 format_id: Annotated[ format_id_1.FormatId | None, Field(description='Format of this creative') ] = 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', ) creative_id: Annotated[str, Field(description='Creative ID from the request')] 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') ] platform_id: Annotated[ str | None, Field(description='Platform-specific ID assigned to the creative') ] = None 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 warnings: Annotated[ list[str] | None, Field(description='Non-fatal warnings about this creative') ] = None preview_url: Annotated[ AnyUrl | None, Field( description='Preview URL for generative creatives (only present for generative formats)' ), ] = None expires_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when preview link expires (only present when preview_url exists)' ), ] = None 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)' ), ] = 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_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." ), ] agent_name: Annotated[ str | None, Field(description='Human-readable name for the creative agent') ] = None 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', ) creative_id: Annotated[str, Field(description='Creative identifier')] approval_status: creative_approval_status.CreativeApprovalStatus 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', ) creative_id: Annotated[str, Field(description='Unique identifier for the creative')] name: Annotated[str, Field(description='Human-readable creative name')] 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.' ), ] 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'), ] inputs: Annotated[ list[Input] | None, Field( description='Preview contexts for generative formats - defines what scenarios to generate previews for' ), ] = None tags: Annotated[ list[str] | None, Field(description='User-defined tags for organization and searchability') ] = 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 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, ), ] = None 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).' ), ] = 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')] 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, ), ] = None 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, ), ] = 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 format_types: Annotated[ list[str] | None, Field( description="Filter by high-level format types (e.g., 'video', 'audio', 'display'). For specific format matching, use format_ids instead.", min_length=1, ), ] = 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 name_contains: Annotated[ str | None, Field(description='Filter by creative names containing this text (case-insensitive)'), ] = None creative_ids: Annotated[ list[str] | None, Field(description='Filter by specific creative IDs', max_length=100, 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 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)'), ] = 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 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 buyer_refs: Annotated[ list[str] | None, Field( description='Filter creatives assigned to media buys with any of these buyer references. Sales-agent-specific — standalone creative agents SHOULD ignore this filter.', 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 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 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 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_variables: Annotated[ bool | None, Field( description='When true, return only creatives with dynamic variables (DCO). When false, return only static creatives.' ), ] = 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 buyer_refs : 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 format_types : list[str] | 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', ) 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'})." ), ] 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." ), ] 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.' ), ] = None 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 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 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'), ] templates_available: Annotated[ bool, Field(description='Whether creative templates are provided') ] 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.' ), ] = 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 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' approved = 'approved' rejected = 'rejected' pending_review = 'pending_review' 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): variant_id: Annotated[str, Field(description='Platform-assigned identifier for this variant')] 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 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.' ), ] = 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
- 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', ) delivery_type: Annotated[ Literal['url'], Field(description='Discriminator indicating DAAST is delivered via URL endpoint'), ] url: Annotated[AnyUrl, Field(description='URL endpoint that returns DAAST XML')] daast_version: Annotated[ daast_version_1.DaastVersion | None, Field(description='DAAST specification version') ] = None duration_ms: Annotated[ int | None, Field(description='Expected audio duration in milliseconds (if known)', ge=0) ] = None tracking_events: Annotated[ list[daast_tracking_event.DaastTrackingEvent] | None, Field(description='Tracking events supported by this DAAST tag'), ] = None companion_ads: Annotated[ bool | None, Field(description='Whether companion display ads are included') ] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = 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 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', ) delivery_type: Annotated[ Literal['inline'], Field(description='Discriminator indicating DAAST is delivered as inline XML content'), ] content: Annotated[str, Field(description='Inline DAAST XML content')] daast_version: Annotated[ daast_version_1.DaastVersion | None, Field(description='DAAST specification version') ] = None duration_ms: Annotated[ int | None, Field(description='Expected audio duration in milliseconds (if known)', ge=0) ] = None tracking_events: Annotated[ list[daast_tracking_event.DaastTrackingEvent] | None, Field(description='Tracking events supported by this DAAST tag'), ] = None companion_ads: Annotated[ bool | None, Field(description='Whether companion display ads are included') ] = None transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the audio content') ] = 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 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', ) 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)] spend: Annotated[float, Field(description='Daily spend for this package', ge=0.0)] conversions: Annotated[ float | None, Field(description='Daily conversions for this package', ge=0.0) ] = None conversion_value: Annotated[ float | None, Field(description='Daily conversion value for this package', ge=0.0) ] = None roas: Annotated[ float | None, Field(description='Daily return on ad spend (conversion_value / spend)', ge=0.0), ] = None 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, ), ] = 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 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', ) start: Annotated[date_aliased, Field(description='Start date (inclusive), ISO 8601')] end: Annotated[date_aliased, Field(description='End 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', ) start: Annotated[AwareDatetime, Field(description='Start timestamp (inclusive), ISO 8601')] end: Annotated[AwareDatetime, Field(description='End 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, ), ] 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, ), ] 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')" ), ] = 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 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', ) list_id: Annotated[str, Field(description='ID of the property list to delete')] 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 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')] list_id: Annotated[str, Field(description='ID of the deleted list')] 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 deleted : boolvar ext : ExtensionObject | Nonevar list_id : strvar model_config
Inherited members
class DeliverTo (**data: Any)-
Expand source code
class DeliverTo(_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
Subclasses
- adcp.types._generated.DeliverTo1
Class variables
var model_config
Inherited members
class DeliveryForecast (**data: Any)-
Expand source code
class DeliveryForecast(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) points: Annotated[ list[forecast_point.ForecastPoint], Field( description='Forecasted delivery at one or more budget levels. A single point is a standard forecast; multiple points ordered by ascending budget form a curve showing how metrics scale with spend. Each point pairs a budget with metric ranges.', min_length=1, ), ] 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. 'reach_freq': points at ascending reach/frequency targets. 'weekly'/'daily': metrics are per-period values. 'clicks'/'conversions': points at ascending outcome targets." ), ] = None method: Annotated[ forecast_method.ForecastMethod, Field(description='Method used to produce this forecast') ] currency: Annotated[ str, Field( description='ISO 4217 currency code for monetary values in this forecast (spend, budget)' ), ] 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 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 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 generated_at: Annotated[ AwareDatetime | None, Field(description='When this forecast was computed') ] = 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.' ), ] = 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 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): 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')" ), ] 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')" ), ] = 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 notes : str | Nonevar provider : str
Inherited members
class DeliveryMetrics (**data: Any)-
Expand source code
class DeliveryMetrics(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) impressions: Annotated[float | None, Field(description='Impressions delivered', ge=0.0)] = None spend: Annotated[float | None, Field(description='Amount spent', ge=0.0)] = None clicks: Annotated[float | None, Field(description='Total clicks', ge=0.0)] = None ctr: Annotated[ float | None, Field(description='Click-through rate (clicks/impressions)', ge=0.0, le=1.0) ] = None views: Annotated[float | None, Field(description='Views at threshold (for CPV)', 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 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 conversion_value: Annotated[ float | None, Field( description='Total monetary value of attributed conversions (in the reporting currency)', ge=0.0, ), ] = None roas: Annotated[ float | None, Field(description='Return on ad spend (conversion_value / spend)', ge=0.0) ] = None cost_per_acquisition: Annotated[ float | None, Field(description='Cost per conversion (spend / conversions)', 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 leads: Annotated[ float | None, Field( description="Leads generated (convenience alias for by_event_type where event_type='lead')", ge=0.0, ), ] = 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 grps: Annotated[ float | None, Field(description='Gross Rating Points delivered (for CPP)', ge=0.0) ] = None reach: Annotated[ float | None, Field( description='Unique reach - units depend on measurement provider (e.g., individuals, households, devices, cookies). See delivery_measurement.provider for methodology.', ge=0.0, ), ] = None frequency: Annotated[ float | None, Field( description='Average frequency per individual (typically measured over campaign duration, but can vary by measurement provider)', ge=0.0, ), ] = None quartile_data: Annotated[ QuartileData | None, Field(description='Video quartile completion data') ] = None dooh_metrics: Annotated[ DoohMetrics | None, Field(description='DOOH-specific metrics (only included for DOOH campaigns)'), ] = 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 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 saves: Annotated[ float | None, Field( description='Saves, bookmarks, playlist adds, pins attributed to this delivery.', ge=0.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 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 cost_per_click: Annotated[ float | None, Field(description='Cost per click (spend / clicks)', ge=0.0) ] = None 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.' ), ] = 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 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', ) type: Annotated[ Literal['platform'], Field(description='Discriminator indicating this is a platform-based deployment'), ] platform: Annotated[str, Field(description='Platform identifier for DSPs')] account: Annotated[str | None, Field(description='Account identifier if applicable')] = None is_live: Annotated[ bool, Field(description='Whether signal is currently active on this deployment') ] 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 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 deployed_at: Annotated[ AwareDatetime | None, Field(description='Timestamp when activation completed (if is_live=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 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', ) type: Annotated[ Literal['agent'], Field(description='Discriminator indicating this is an agent URL-based deployment'), ] agent_url: Annotated[AnyUrl, Field(description='URL identifying the deployment agent')] account: Annotated[str | None, Field(description='Account identifier if applicable')] = None is_live: Annotated[ bool, Field(description='Whether signal is currently active on this deployment') ] 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 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 deployed_at: Annotated[ AwareDatetime | None, Field(description='Timestamp when activation completed (if is_live=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 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', ) type: Annotated[ Literal['platform'], Field(description='Discriminator indicating this is a platform-based deployment'), ] platform: Annotated[ str, Field(description="Platform identifier for DSPs (e.g., 'the-trade-desk', 'amazon-dsp')"), ] account: Annotated[ str | None, Field(description='Optional account identifier on the platform') ] = 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 : 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', ) type: Annotated[ Literal['agent'], Field(description='Discriminator indicating this is an agent URL-based deployment'), ] agent_url: Annotated[ AnyUrl, Field(description='URL identifying the deployment agent (for sales agents, etc.)') ] account: Annotated[ str | None, Field(description='Optional account identifier on the agent') ] = 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 : 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'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 px
class Unit (*args, **kwds)-
Expand source code
class DimensionUnit(Enum): px = 'px' dp = 'dp' inches = 'inches' cm = 'cm'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 px
class Disclaimer (**data: Any)-
Expand source code
class Disclaimer(AdCPBaseModel): text: str context: str | None = None required: bool | None = 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 : 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', ) loop_plays: Annotated[ int | None, Field(description='Number of times ad played in rotation', ge=0) ] = None screens_used: Annotated[ int | None, Field(description='Number of unique screens displaying the ad', ge=0) ] = None screen_time_seconds: Annotated[ int | None, Field(description='Total display time in seconds', 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 calculation_notes: Annotated[ str | None, Field(description='Explanation of how DOOH impressions were calculated') ] = 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.' ), ] message: Annotated[str, Field(description='Human-readable error message')] field: Annotated[ str | None, Field(description="Field path associated with the error (e.g., 'packages[0].targeting')"), ] = None suggestion: Annotated[str | None, Field(description='Suggested fix for the error')] = None retry_after: Annotated[ float | None, Field(description='Seconds to wait before retrying the operation', ge=0.0) ] = None details: Annotated[ dict[str, Any] | None, Field(description='Additional task-specific error details') ] = None 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).' ), ] = 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' CONFLICT = 'CONFLICT'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_EXHAUSTEDvar BUDGET_TOO_LOWvar COMPLIANCE_UNSATISFIEDvar CONFLICTvar CREATIVE_REJECTEDvar INVALID_REQUESTvar POLICY_VIOLATIONvar PRODUCT_NOT_FOUNDvar PRODUCT_UNAVAILABLEvar PROPOSAL_EXPIREDvar RATE_LIMITEDvar SERVICE_UNAVAILABLEvar UNSUPPORTED_FEATURE
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): created_at = 'created_at' updated_at = 'updated_at' status = 'status' task_type = 'task_type' domain = 'domain'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 created_atvar domainvar statusvar task_typevar updated_at
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' show_ids = 'show_ids' episodes = 'episodes' brief_relevance = 'brief_relevance' expires_at = 'expires_at' product_card = 'product_card' product_card_detailed = 'product_card_detailed'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 conversion_trackingvar creative_policyvar data_provider_signalsvar delivery_measurementvar delivery_typevar descriptionvar episodesvar exclusivityvar expires_atvar forecastvar format_idsvar max_optimization_goalsvar metric_optimizationvar namevar outcome_measurementvar placementsvar pricing_optionsvar product_cardvar product_card_detailedvar product_idvar publisher_propertiesvar reporting_capabilitiesvar show_ids
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' show_ids = 'show_ids' episodes = 'episodes' brief_relevance = 'brief_relevance' expires_at = 'expires_at' product_card = 'product_card' product_card_detailed = 'product_card_detailed'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 conversion_trackingvar creative_policyvar data_provider_signalsvar delivery_measurementvar delivery_typevar descriptionvar episodesvar exclusivityvar expires_atvar forecastvar format_idsvar max_optimization_goalsvar metric_optimizationvar namevar outcome_measurementvar placementsvar pricing_optionsvar product_cardvar product_card_detailedvar product_idvar publisher_propertiesvar reporting_capabilitiesvar show_ids
class GetBrandIdentityField (*args, **kwds)-
Expand source code
class FieldModel(Enum): description = 'description' industry = 'industry' 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 industryvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['flat_rate'], Field(description='Fixed cost regardless of delivery volume') ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parameters | 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', ) primary: Annotated[str | None, Field(description='Primary font family')] = None secondary: Annotated[str | None, Field(description='Secondary font family')] = None font_urls: Annotated[list[AnyUrl] | None, Field(description='URLs to web font files')] = 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, Field( description='Budget amount for this forecast point. 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.', ge=0.0, ), ] metrics: Annotated[ Metrics, Field( description='Forecasted metric values at this budget level. 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. Include spend when the platform predicts it will differ from budget. 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 : floatvar metrics : Metricsvar model_config
Inherited members
class ForecastRange (**data: Any)-
Expand source code
class ForecastRange(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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)] high: Annotated[ float | None, Field(description='Optimistic (high-end) forecast value', 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 high : float | Nonevar low : float | Nonevar mid : floatvar model_config
Inherited members
class ForecastRangeUnit (*args, **kwds)-
Expand source code
class ForecastRangeUnit(Enum): spend = 'spend' 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 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', ) format_id: Annotated[ format_id_1.FormatId, Field(description='Structured format identifier with agent URL and format name'), ] name: Annotated[str, Field(description='Human-readable format name')] description: Annotated[ str | None, Field( description='Plain text explanation of what this format does and what assets it requires' ), ] = None example_url: Annotated[ AnyUrl | None, Field( description='Optional URL to showcase page with examples and interactive demos of this format' ), ] = None type: Annotated[ format_category.FormatCategory | None, Field( description='DEPRECATED: High-level category for this format. Use the assets array to understand creative requirements instead - it provides precise information about what asset types are needed.' ), ] = None 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 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 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 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.' ), ] = None 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 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 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 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 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 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 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 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, ), ] = 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] | Nonevar type : FormatCategory | 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 FormatCategory (*args, **kwds)-
Expand source code
class FormatCategory(Enum): audio = 'audio' video = 'video' display = 'display' native = 'native' dooh = 'dooh' rich_media = 'rich_media' universal = 'universal'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 displayvar doohvar nativevar rich_mediavar universalvar video
class FormatType (*args, **kwds)-
Expand source code
class FormatCategory(Enum): audio = 'audio' video = 'video' display = 'display' native = 'native' dooh = 'dooh' rich_media = 'rich_media' universal = 'universal'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 displayvar doohvar nativevar rich_mediavar universalvar video
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)" ), ] 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, ), ] = 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 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, ), ] = 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', ) 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 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 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.'), ] period: Annotated[ date_range.DateRange | None, Field( description='Date range for the spend summary. Defaults to the current billing cycle if omitted.' ), ] = None 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 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'), ] currency: Annotated[ str, Field( description='ISO 4217 currency code for all monetary amounts in this response', pattern='^[A-Z]{3}$', ), ] 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.' ), ] 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." ), ] spend: Annotated[Spend | None, Field(description='Spend summary for the period')] = None credit: Annotated[ Credit | None, Field( description='Credit status. Present for credit-based accounts (payment_terms like net_30).' ), ] = None balance: Annotated[ Balance | None, Field(description='Prepay balance. Present for prepay accounts.') ] = 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 invoices: Annotated[ list[Invoice] | None, Field(description='Recent invoices. Sellers may limit the number returned.'), ] = None 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 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', ) errors: Annotated[list[error.Error], Field(description='Operation-level errors', min_length=1)] 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 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', ) protocols: Annotated[ list[Protocol] | None, Field( description='Specific protocols to query capabilities for. If omitted, returns capabilities for all supported protocols.', min_length=1, ), ] = None 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_configvar protocols : list[Protocol] | None
Inherited members
class GetAdcpCapabilitiesResponse (**data: Any)-
Expand source code
class GetAdcpCapabilitiesResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) adcp: Annotated[Adcp, Field(description='Core AdCP protocol information')] supported_protocols: Annotated[ list[SupportedProtocol], Field(description='Which AdCP domain protocols this seller supports', min_length=1), ] 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 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 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 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 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 creative: Annotated[ Creative | None, Field( description='Creative protocol capabilities. Only present if creative is in supported_protocols.' ), ] = 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 last_updated: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp of when capabilities were last updated. Buyers can use this for cache invalidation.' ), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None 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 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 GetContentStandardsRequest (**data: Any)-
Expand source code
class GetContentStandardsRequest(AdCPBaseModel): standards_id: Annotated[ str, Field(description='Identifier for the standards configuration to retrieve') ] 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_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): errors: list[error.Error] 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 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 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 media_buy_buyer_refs: Annotated[ list[str] | None, Field( description="Filter to specific media buys by buyer reference ID. Alternative to media_buy_ids when the buyer doesn't have the publisher's identifiers.", min_length=1, ), ] = 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 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}$', ), ] = 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 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 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 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 account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_buyer_refs : list[str] | 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 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 media_buy_buyer_refs: Annotated[ list[str] | None, Field( description="Filter to specific media buys by buyer reference ID. Alternative to media_buy_ids when the buyer doesn't have the publisher's identifiers.", min_length=1, ), ] = 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 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}$', ), ] = 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 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 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 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 account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_buyer_refs : list[str] | 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 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 media_buy_buyer_refs: Annotated[ list[str] | None, Field( description="Filter to specific media buys by buyer reference ID. Alternative to media_buy_ids when the buyer doesn't have the publisher's identifiers.", min_length=1, ), ] = 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 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}$', ), ] = 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 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 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 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 account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_buyer_refs : list[str] | 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 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 media_buy_buyer_refs: Annotated[ list[str] | None, Field( description="Filter to specific media buys by buyer reference ID. Alternative to media_buy_ids when the buyer doesn't have the publisher's identifiers.", min_length=1, ), ] = 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 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}$', ), ] = 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 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 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 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 account : AccountReference | Nonevar context : ContextObject | Nonevar creative_ids : list[str] | Nonevar end_date : str | Nonevar ext : ExtensionObject | Nonevar max_variants : int | Nonevar media_buy_buyer_refs : list[str] | 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 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 media_buy_buyer_ref: Annotated[ str | None, Field( description="Buyer's reference identifier for the media buy. Echoed back so the buyer can correlate without mapping publisher IDs." ), ] = None currency: Annotated[ str, Field( description="ISO 4217 currency code for monetary values in this response (e.g., 'USD', 'EUR')", pattern='^[A-Z]{3}$', ), ] reporting_period: Annotated[ReportingPeriod, Field(description='Date range for the report.')] creatives: Annotated[ list[Creative], Field(description='Creative delivery data with variant breakdowns') ] pagination: Annotated[ Pagination | None, Field( description='Pagination information. Present when the request included pagination parameters.' ), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None 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 account_id : str | Nonevar context : ContextObject | Nonevar creatives : list[Creative]var currency : strvar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar media_buy_buyer_ref : str | 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', ) creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='The creative manifest to evaluate. Contains format_id and assets.'), ] feature_ids: Annotated[ list[str] | None, Field( description='Optional filter to specific features. If omitted, returns all available features.', min_length=1, ), ] = None 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 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 : 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): results: Annotated[ list[creative_feature_result.CreativeFeatureResult], Field(description='Feature values for the evaluated creative'), ] 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 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 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): errors: list[error.Error] 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 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 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 sampling: Annotated[ Sampling | None, Field( description='Sampling parameters. Defaults to the sampling rate agreed in the media buy.' ), ] = None time_range: Annotated[TimeRange | None, Field(description='Filter to specific time period')] = ( None ) pagination: Annotated[ Pagination | None, Field( description='Pagination parameters. Uses higher limits than standard pagination because artifact result sets can be very large.' ), ] = None 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 account : AccountReference | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar package_ids : list[str] | Nonevar pagination : Pagination | Nonevar sampling : Sampling | Nonevar time_range : TimeRange | None
Inherited members
class GetMediaBuyArtifactsSuccessResponse (**data: Any)-
Expand source code
class GetMediaBuyArtifactsResponse1(AdCPBaseModel): media_buy_id: Annotated[str, Field(description='Media buy these artifacts belong to')] artifacts: Annotated[ list[Artifact], Field(description='Delivery records with full artifact content') ] sampling_info: Annotated[ SamplingInfo | None, Field(description='Information about how the sample was generated') ] = None pagination: pagination_response.PaginationResponse | None = None 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 artifacts : list[Artifact]var context : ContextObject | Nonevar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar pagination : PaginationResponse | Nonevar sampling_info : SamplingInfo | None
Inherited members
class GetMediaBuyArtifactsErrorResponse (**data: Any)-
Expand source code
class GetMediaBuyArtifactsResponse2(AdCPBaseModel): errors: list[error.Error] 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 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 media_buy_ids: Annotated[ list[str] | None, Field( description='Array of publisher media buy IDs to get delivery data for', min_length=1 ), ] = None buyer_refs: Annotated[ list[str] | None, Field(description='Array of buyer reference IDs to get delivery data for', min_length=1), ] = None status_filter: Annotated[ media_buy_status.MediaBuyStatus | StatusFilter | None, Field(description='Filter by status. Can be a single status or array of statuses'), ] = 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 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 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 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 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 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 account : AccountReference | Nonevar attribution_window : AttributionWindow | Nonevar buyer_refs : list[str] | 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', ) 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 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, ), ] = None sequence_number: Annotated[ int | None, Field( description='Sequential notification number (only present in webhook deliveries, starts at 1)', ge=1, ), ] = None 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 reporting_period: Annotated[ ReportingPeriod, Field(description='Date range for the report. All periods use UTC timezone.'), ] currency: Annotated[str, Field(description='ISO 4217 currency code', pattern='^[A-Z]{3}$')] 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 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 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.' ), ] errors: Annotated[ list[error.Error] | None, Field( description='Task-specific errors and warnings (e.g., missing delivery data, reporting platform issues)' ), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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 media_buy_ids: Annotated[ list[str] | None, Field( description='Array of publisher media buy IDs to retrieve. When omitted along with buyer_refs, returns a paginated set of accessible media buys matching status_filter.', min_length=1, ), ] = None buyer_refs: Annotated[ list[str] | None, Field(description='Array of buyer reference IDs to retrieve', min_length=1), ] = 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"] only when media_buy_ids and buyer_refs are both omitted. When media_buy_ids or buyer_refs are provided, no implicit status filter is applied.' ), ] = None 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 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 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 account : AccountReference | Nonevar buyer_refs : list[str] | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | 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', ) media_buys: Annotated[ list[MediaBuy], Field( description='Array of media buys with status, creative approval state, and optional delivery snapshots' ), ] errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors (e.g., media buy not found)'), ] = None 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.'), ] = None 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 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', ) 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, ), ] = None buyer_campaign_ref: Annotated[ str | None, Field(description='Filter to a specific campaign. Omit for plan-level aggregate.'), ] = None include_entries: Annotated[ bool | None, Field(description='Include the full audit trail. Default: false.') ] = 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 buyer_campaign_ref : str | Nonevar 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 GetProductsBriefRequest (**data: Any)-
Expand source code
class GetProductsRequest1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) buying_mode: Annotated[ Literal['brief'], 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'." ), ] brief: Annotated[ str, 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'." ), ] refine: Any | None = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None 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 account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label. Groups related discovery and buy operations under a single campaign for CRM and ad server correlation (e.g., 'NovaDrink_Meals_Q2')." ), ] = 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 filters: product_filters.ProductFilters | None = 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 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 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.' ), ] = None pagination: pagination_request.PaginationRequest | None = None context: context_1.ContextObject | None = 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 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 : AccountReference | Nonevar brand : BrandReference | Nonevar brief : strvar buyer_campaign_ref : str | Nonevar buying_mode : Literal['brief']var 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 : typing.Any | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
Inherited members
class GetProductsWholesaleRequest (**data: Any)-
Expand source code
class GetProductsRequest2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) buying_mode: Annotated[ Literal['wholesale'], 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'." ), ] brief: Any | None = None refine: Any | None = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None 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 account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label. Groups related discovery and buy operations under a single campaign for CRM and ad server correlation (e.g., 'NovaDrink_Meals_Q2')." ), ] = 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 filters: product_filters.ProductFilters | None = 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 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 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.' ), ] = None pagination: pagination_request.PaginationRequest | None = None context: context_1.ContextObject | None = 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 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 : AccountReference | Nonevar brand : BrandReference | Nonevar brief : typing.Any | Nonevar buyer_campaign_ref : str | Nonevar buying_mode : Literal['wholesale']var 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 : typing.Any | Nonevar required_policies : list[str] | Nonevar time_budget : Duration | None
Inherited members
class GetProductsRefineRequest (**data: Any)-
Expand source code
class GetProductsRequest3(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) buying_mode: Annotated[ Literal['refine'], 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'." ), ] brief: Any | None = None refine: Annotated[ list[Refine | Refine1 | Refine2], 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, ), ] brand: Annotated[ brand_ref.BrandReference | None, Field( description='Brand reference for product discovery context. Resolved to full brand identity at execution time.' ), ] = None 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 account: Annotated[ account_ref.AccountReference | None, Field( description="Account for product lookup. Returns products with pricing specific to this account's rate card." ), ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label. Groups related discovery and buy operations under a single campaign for CRM and ad server correlation (e.g., 'NovaDrink_Meals_Q2')." ), ] = 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 filters: product_filters.ProductFilters | None = 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 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 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.' ), ] = None pagination: pagination_request.PaginationRequest | None = None context: context_1.ContextObject | None = 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 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 : AccountReference | Nonevar brand : BrandReference | Nonevar brief : typing.Any | Nonevar buyer_campaign_ref : str | Nonevar buying_mode : Literal['refine']var 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]var 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', ) products: Annotated[list[product_1.Product], Field(description='Array of matching products')] shows: Annotated[ list[show.Show] | None, Field( description="Shows referenced by products in this response. Only includes shows referenced by the returned products. Under pagination, each page includes all show objects needed for that page's products." ), ] = 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 errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings (e.g., product filtering issues)'), ] = None 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 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 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 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 sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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 | Nonevar shows : list[Show] | None
Inherited members
class GetPropertyListRequest (**data: Any)-
Expand source code
class GetPropertyListRequest(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) list_id: Annotated[str, Field(description='ID of the property list to retrieve')] resolve: Annotated[ bool | None, Field( description='Whether to apply filters and return resolved identifiers (default: true)' ), ] = True 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 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 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', ) list: Annotated[ property_list.PropertyList, Field(description='The property list metadata (always returned)'), ] identifiers: Annotated[ _list[identifier.Identifier] | None, Field( description='Resolved identifiers that passed filters (if resolve=true). Cache these locally for real-time use.' ), ] = None pagination: pagination_response.PaginationResponse | None = None resolved_at: Annotated[ AwareDatetime | None, Field(description='When the list was resolved') ] = None 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 = 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 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 buyer_campaign_ref: Annotated[ str | None, Field( description="The buyer's campaign reference. Used to correlate signal discovery with subsequent report_usage calls." ), ] = 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.' ), ] = 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 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 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 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 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 account : AccountReference | Nonevar buyer_campaign_ref : str | 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 buyer_campaign_ref: Annotated[ str | None, Field( description="The buyer's campaign reference. Used to correlate signal discovery with subsequent report_usage calls." ), ] = 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.' ), ] = 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 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 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 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 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 account : AccountReference | Nonevar buyer_campaign_ref : str | 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 buyer_campaign_ref: Annotated[ str | None, Field( description="The buyer's campaign reference. Used to correlate signal discovery with subsequent report_usage calls." ), ] = 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.' ), ] = 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 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 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 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 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 account : AccountReference | Nonevar buyer_campaign_ref : str | 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', ) signals: Annotated[list[Signal], Field(description='Array of matching signals')] errors: Annotated[ list[error.Error] | None, Field( description='Task-specific errors and warnings (e.g., signal discovery or pricing issues)' ), ] = None pagination: pagination_response.PaginationResponse | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) content: Annotated[str, Field(description='HTML content')] version: Annotated[str | None, Field(description="HTML version (e.g., 'HTML5')")] = None accessibility: Annotated[ Accessibility | None, Field(description='Self-declared accessibility properties for this opaque creative'), ] = 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 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[ identifier_types.PropertyIdentifierTypes, Field(description='Type of identifier') ] value: Annotated[ str, Field( description="The identifier value. For domain type: 'example.com' matches base domain plus www and m subdomains; 'edition.example.com' matches that specific subdomain; '*.example.com' matches ALL subdomains but NOT base domain" ), ]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 : PropertyIdentifierTypesvar value : str
Inherited members
class ImageAsset (**data: Any)-
Expand source code
class ImageAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) url: Annotated[AnyUrl, Field(description='URL to the image asset')] width: Annotated[int, Field(description='Width in pixels', ge=1)] height: Annotated[int, Field(description='Height in pixels', ge=1)] format: Annotated[ str | None, Field(description='Image file format (jpg, png, gif, webp, etc.)') ] = None alt_text: Annotated[str | None, Field(description='Alternative text for accessibility')] = None provenance: Annotated[ provenance_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 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', ) name: Annotated[str, Field(description='Human-readable name for this preview variant')] macros: Annotated[ dict[str, str] | None, Field(description='Macro values to apply for this preview') ] = None context_description: Annotated[ str | None, Field(description='Natural language description of the context for AI-generated 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 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', ) content: Annotated[str, Field(description='JavaScript content')] module_type: Annotated[ javascript_module_type.JavascriptModuleType | None, Field(description='JavaScript module type'), ] = None accessibility: Annotated[ Accessibility | None, Field(description='Self-declared accessibility properties for this opaque creative'), ] = 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', ) status: Annotated[ Status | None, Field(description='Filter accounts by status. Omit to return accounts in all statuses.'), ] = 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 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_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'), ] errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors and warnings') ] = None pagination: pagination_response.PaginationResponse | None = None 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 accounts : list[Account]var context : ContextObject | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar pagination : PaginationResponse | None
Inherited members
class ListAuthorizedPropertiesRequest (**data: Any)-
Expand source code
class ListAuthorizedPropertiesRequest(_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 ListAuthorizedPropertiesResponse (**data: Any)-
Expand source code
class ListAuthorizedPropertiesResponse(_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 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 languages: Annotated[ list[str] | None, Field(description='Filter by BCP 47 language tags', min_length=1) ] = None countries: Annotated[ list[str] | None, Field(description='Filter by ISO 3166-1 alpha-2 country codes', min_length=1), ] = None pagination: pagination_request.PaginationRequest | None = None 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 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): standards: Annotated[ list[content_standards.ContentStandards], Field(description='Array of content standards configurations matching the filter criteria'), ] pagination: pagination_response.PaginationResponse | None = None 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_configvar pagination : PaginationResponse | Nonevar standards : list[ContentStandards]
Inherited members
class ListContentStandardsErrorResponse (**data: Any)-
Expand source code
class ListContentStandardsResponse2(AdCPBaseModel): errors: list[error.Error] 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 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', ) 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 type: Annotated[ format_category.FormatCategory | None, Field( description='Filter by format type (technical categories with distinct requirements)' ), ] = None 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 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 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 min_width: Annotated[ int | None, Field( description='Minimum width in pixels (inclusive). Returns formats where ANY render has width >= this value.' ), ] = None min_height: Annotated[ int | None, Field( description='Minimum height in pixels (inclusive). Returns formats where ANY render has height >= this value.' ), ] = 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 name_search: Annotated[ str | None, Field(description='Search for formats by name (case-insensitive partial match)') ] = 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)' ), ] = 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 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 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 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 pagination: pagination_request.PaginationRequest | None = None 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 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 type : FormatCategory | Nonevar wcag_level : WcagLevel | None
Inherited members
class ListCreativeFormatsResponse (**data: Any)-
Expand source code
class ListCreativeFormatsResponse(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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." ), ] 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 pagination: pagination_response.PaginationResponse | None = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) filters: creative_filters.CreativeFilters | None = None sort: Annotated[Sort | None, Field(description='Sorting parameters')] = None pagination: pagination_request.PaginationRequest | None = None include_assignments: Annotated[ bool | None, Field(description='Include package assignment information in response') ] = True 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_items: Annotated[ bool | None, Field(description='Include items for multi-asset formats like carousels and native ads'), ] = False include_variables: Annotated[ bool | None, Field( description='Include dynamic content variable definitions (DCO slots) for each creative' ), ] = False 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 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 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', ) query_summary: Annotated[ QuerySummary, Field(description='Summary of the query that was executed') ] pagination: pagination_response.PaginationResponse creatives: Annotated[ list[Creative], Field(description='Array of creative assets matching the query') ] 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 status_summary: Annotated[ StatusSummary | None, Field(description='Breakdown of creatives by status') ] = None errors: Annotated[ list[error.Error] | None, Field(description='Task-specific errors (e.g., invalid filters, account not found)'), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) principal: Annotated[ str | None, Field(description='Filter to lists owned by this principal') ] = None name_contains: Annotated[ str | None, Field(description='Filter to lists whose name contains this string') ] = None pagination: pagination_request.PaginationRequest | None = None 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_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', ) lists: Annotated[ list[property_list.PropertyList], Field(description='Array of property lists (metadata only, not resolved properties)'), ] pagination: pagination_response.PaginationResponse | 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 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', ) event_source_id: Annotated[ str, Field(description='Event source configured on the account via sync_event_sources') ] 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." ), ] = None events: Annotated[ list[event.Event], Field(description='Events to log', max_length=10000, min_length=1) ] 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 event_source_id : strvar events : list[Event]var ext : ExtensionObject | 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', ) events_received: Annotated[int, Field(description='Number of events received', ge=0)] events_processed: Annotated[ int, Field(description='Number of events successfully queued for processing', ge=0) ] partial_failures: Annotated[ list[PartialFailure] | None, Field(description='Events that failed validation') ] = None warnings: Annotated[ list[str] | None, Field( description='Non-fatal issues (low match quality, missing recommended fields, deprecation notices)' ), ] = 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 sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) errors: Annotated[list[error.Error], Field(description='Operation-level errors', min_length=1)] 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 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', ) url: Annotated[AnyUrl, Field(description='URL to the logo asset')] orientation: Annotated[ Orientation | None, Field(description='Logo aspect ratio orientation') ] = None background: Annotated[Background | None, Field(description='Background compatibility')] = None variant: Annotated[Variant | None, Field(description='Logo variant type')] = None tags: Annotated[list[str] | None, Field(description='Additional semantic tags')] = None usage: Annotated[str | None, Field(description='When to use this logo variant')] = None width: Annotated[int | None, Field(description='Width in pixels')] = None height: Annotated[int | None, Field(description='Height 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 : Background | 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', ) 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 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.' ), ] domain: Annotated[ adcp_domain.AdcpDomain | None, Field( description='AdCP domain this task belongs to. Helps classify the operation type at a high level.' ), ] = None status: Annotated[ task_status.TaskStatus, Field( description='Current task status. Webhooks are triggered for status changes after initial submission.' ), ] timestamp: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when this webhook was generated.') ] 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 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 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.' ), ] = 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 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', ) start: Annotated[ AwareDatetime, Field(description='ISO 8601 start timestamp for measurement period') ] end: Annotated[ AwareDatetime, Field(description='ISO 8601 end 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', ) media_buy_id: Annotated[ str, Field(description="Publisher's unique identifier for the media buy") ] buyer_ref: Annotated[ str | None, Field( description="Buyer's reference identifier for this media buy. Sellers SHOULD deduplicate requests with the same buyer_ref and account, returning the existing media buy rather than creating a duplicate." ), ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label. Groups related operations under a single campaign for CRM and ad server correlation." ), ] = None account: Annotated[ account_1.Account | None, Field(description='Account billed for this media buy') ] = None status: media_buy_status.MediaBuyStatus rejection_reason: Annotated[ str | None, Field( description="Reason provided by the seller when status is 'rejected'. Present only when status is 'rejected'." ), ] = None total_budget: Annotated[float, Field(description='Total budget amount', ge=0.0)] packages: Annotated[ list[package.Package], Field(description='Array of packages within this media buy') ] creative_deadline: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp for creative upload deadline') ] = None created_at: Annotated[AwareDatetime | None, Field(description='Creation timestamp')] = None updated_at: Annotated[AwareDatetime | None, Field(description='Last update timestamp')] = 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 : Account | Nonevar buyer_campaign_ref : str | Nonevar buyer_ref : str | Nonevar created_at : pydantic.types.AwareDatetime | Nonevar creative_deadline : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar media_buy_id : strvar model_configvar packages : list[Package]var rejection_reason : str | 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', ) media_buy_id: Annotated[str, Field(description="Publisher's media buy identifier")] buyer_ref: Annotated[ str | None, Field(description="Buyer's reference identifier for this media buy") ] = None buyer_campaign_ref: Annotated[ str | None, Field( description="Buyer's campaign reference label from create_media_buy.buyer_campaign_ref. Groups related operations under a single campaign for CRM and ad server correlation; may be absent when not provided at creation time." ), ] = 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.' ), ] 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 pricing_model: Annotated[ pricing_model_1.PricingModel | None, Field(description='Pricing model used for this media buy'), ] = None totals: Totals by_package: Annotated[list[ByPackageItem], Field(description='Metrics broken down by package')] daily_breakdown: Annotated[ list[DailyBreakdownItem1] | None, Field(description='Day-by-day delivery') ] = 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 buyer_campaign_ref : str | Nonevar buyer_ref : str | Nonevar 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' ai_media = 'ai_media'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 ai_mediavar cinemavar ctvvar displayvar doohvar emailvar gamingvar influencervar linear_tvvar olvvar oohvar podcastvar printvar product_placementvar radiovar retail_mediavar searchvar 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', ) canonical: Annotated[AnyUrl | None, Field(description='Canonical URL')] = None author: Annotated[str | None, Field(description='Artifact author name')] = 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 ) json_ld: Annotated[ list[dict[str, Any]] | None, Field(description='JSON-LD structured data (schema.org)') ] = 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 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 Offering (**data: Any)-
Expand source code
class Offering(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) offering_id: Annotated[ str, Field( description='Unique identifier for this offering. Used by hosts to reference specific offerings in si_get_offering calls.' ), ] name: Annotated[ str, Field( description="Human-readable offering name (e.g., 'Winter Sale', 'Free Trial', 'Enterprise Platform')" ), ] description: Annotated[str | None, Field(description="Description of what's being offered")] = ( None ) 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.' ), ] = None checkout_url: Annotated[ AnyUrl | None, Field( description="URL for checkout/purchase flow when the brand doesn't support agentic checkout." ), ] = 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 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 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 categories: Annotated[ list[str] | None, Field( description="Categories this offering belongs to (e.g., 'measurement', 'identity', 'programmatic')" ), ] = 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 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_type: Annotated[ asset_content_type.AssetContentType, Field(description='The expected content type for this group.'), ] required: Annotated[ bool | None, Field( description='Whether this asset group must be present in each offering. Defaults to true.' ), ] = True min_count: Annotated[ int | None, Field(description='Minimum number of items required in this group.', ge=1) ] = None max_count: Annotated[ int | None, Field(description='Maximum number of items allowed in this group.', ge=1) ] = None 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 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 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.'), ] 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, ), ] 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 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', ) type: Annotated[ str, Field( description='Type of measurement', examples=['incremental_sales_lift', 'brand_lift', 'foot_traffic'], ), ] attribution: Annotated[ str, Field( description='Attribution methodology', examples=['deterministic_purchase', 'probabilistic'], ), ] window: Annotated[ duration.Duration | None, Field( description='Attribution window as a structured duration (e.g., {"interval": 30, "unit": "days"}).' ), ] = None reporting: Annotated[ str, Field( description='Reporting frequency and format', examples=['weekly_dashboard', 'real_time_api'], ), ]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 attribution : strvar model_configvar reporting : strvar type : strvar window : Duration | None
class Measurement (**data: Any)-
Expand source code
class OutcomeMeasurement(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) type: Annotated[ str, Field( description='Type of measurement', examples=['incremental_sales_lift', 'brand_lift', 'foot_traffic'], ), ] attribution: Annotated[ str, Field( description='Attribution methodology', examples=['deterministic_purchase', 'probabilistic'], ), ] window: Annotated[ duration.Duration | None, Field( description='Attribution window as a structured duration (e.g., {"interval": 30, "unit": "days"}).' ), ] = None reporting: Annotated[ str, Field( description='Reporting frequency and format', examples=['weekly_dashboard', 'real_time_api'], ), ]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 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', ) id: Annotated[ str, Field( description="Identifier for this overlay (e.g., 'play_pause', 'volume', 'publisher_logo', 'carousel_prev', 'carousel_next')" ), ] description: Annotated[ str | None, Field( description='Human-readable explanation of what this overlay is and how buyers should account for it' ), ] = None 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.' ), ] = None 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." ), ]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 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', ) package_id: Annotated[str, Field(description="Publisher's package identifier")] buyer_ref: Annotated[ str | None, Field(description="Buyer's reference identifier for this package") ] = None product_id: Annotated[ str | None, Field(description='Product identifier this package is purchased from') ] = None budget: Annotated[ float | None, Field( description='Package budget amount, denominated in package.currency when present, otherwise media_buy.currency', ge=0.0, ), ] = 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 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 impressions: Annotated[ float | None, Field(description='Goal impression count for impression-based packages', ge=0.0), ] = 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.' ), ] = None end_time: Annotated[ AwareDatetime | None, Field(description='ISO 8601 flight end time for this package') ] = None paused: Annotated[ bool | None, Field(description='Whether this package is currently paused by the buyer') ] = 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 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 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 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 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 bid_price : float | Nonevar budget : float | Nonevar buyer_ref : str | Nonevar creative_approvals : list[CreativeApproval] | 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', ) package_id: Annotated[str, Field(description="Publisher's unique identifier for the package")] buyer_ref: Annotated[ str | None, Field( description="Buyer's reference identifier for this package. Sellers SHOULD deduplicate requests with the same buyer_ref within a media buy, returning the existing package rather than creating a duplicate." ), ] = None product_id: Annotated[ str | None, Field(description='ID of the product this package is based on') ] = None budget: Annotated[ float | None, Field( description='Budget allocation for this package in the currency specified by the pricing option', ge=0.0, ), ] = None pacing: pacing_1.Pacing | None = None pricing_option_id: Annotated[ str | None, Field( description="ID of the selected pricing option from the product's pricing_options array" ), ] = None 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 impressions: Annotated[ float | None, Field(description='Impression goal for this package', ge=0.0) ] = 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 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 targeting_overlay: targeting.TargetingOverlay | None = None creative_assignments: Annotated[ list[creative_assignment.CreativeAssignment] | None, Field(description='Creative assets assigned to this package'), ] = 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 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 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 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 paused: Annotated[ bool | None, Field( description='Whether this package is paused by the buyer. Paused packages do not deliver impressions. Defaults to false.' ), ] = 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 bid_price : float | Nonevar budget : float | Nonevar buyer_ref : str | Nonevar catalogs : list[Catalog] | Nonevar creative_assignments : list[CreativeAssignment] | 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 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', ) buyer_ref: Annotated[ str, Field( description="Buyer's reference identifier for this package. Sellers SHOULD deduplicate requests with the same buyer_ref within a media buy, returning the existing package rather than creating a duplicate." ), ] product_id: Annotated[str, Field(description='Product ID for this package')] 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 budget: Annotated[ float, Field(description="Budget allocation for this package in the media buy's currency", ge=0.0), ] pacing: pacing_1.Pacing | None = None pricing_option_id: Annotated[ str, Field( description="ID of the selected pricing option from the product's pricing_options array" ), ] 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 impressions: Annotated[ float | None, Field(description='Impression goal for this package', ge=0.0) ] = 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. Must fall within the media buy's date range." ), ] = 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 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 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 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 targeting_overlay: targeting.TargetingOverlay | 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 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 bid_price : float | Nonevar budget : floatvar buyer_ref : strvar catalogs : list[Catalog] | 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 PackageStatus (*args, **kwds)-
Expand source code
class PackageStatus(str, _Enum): draft = "draft" active = "active" paused = "paused" completed = "completed"str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str
Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.str() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to 'strict'.
Ancestors
- builtins.str
- enum.Enum
Class variables
var activevar completedvar draftvar paused
class PackageUpdate (**data: Any)-
Expand source code
class PackageUpdate(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) package_id: Annotated[str | None, Field(description="Publisher's ID of package to update")] = ( None ) buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the package to update") ] = 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 pacing: pacing_1.Pacing | None = None 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 impressions: Annotated[ float | None, Field(description='Updated impression goal for this package', ge=0.0) ] = 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 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 paused: Annotated[ bool | None, Field(description='Pause/resume specific package (true = paused, false = active)'), ] = 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 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 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.' ), ] = 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 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 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 bid_price : float | Nonevar budget : float | Nonevar buyer_ref : str | Nonevar catalogs : list[Catalog] | 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 : str | Nonevar 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): total_artifacts: Annotated[ int | None, Field(description='Total artifacts in the delivery period') ] = None batch_number: Annotated[int | None, Field(description='Current batch number (1-indexed)')] = ( 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', ) max_results: Annotated[ int | None, Field(description='Maximum number of items to return per page', ge=1, le=100) ] = 50 cursor: Annotated[ str | None, Field(description='Opaque cursor from a previous response to fetch the next page'), ] = 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 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_system: Annotated[ demographic_system_1.DemographicSystem | None, Field( description='Measurement system for the demographic field. Defaults to nielsen when omitted.' ), ] = None demographic: Annotated[ str, Field( description='Target demographic code within the specified demographic_system (e.g., P18-49 for Nielsen, ABC1 Adults for BARB)' ), ] 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', ) feedback_id: Annotated[ str, Field(description='Unique identifier for this performance feedback submission') ] media_buy_id: Annotated[str, Field(description="Publisher's media buy identifier")] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)' ), ] = None creative_id: Annotated[ str | None, Field(description='Specific creative asset (if feedback is creative-specific)') ] = None measurement_period: Annotated[ MeasurementPeriod, Field(description='Time period for performance measurement') ] performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] metric_type: Annotated[ metric_type_1.MetricType, Field(description='The business metric being measured') ] feedback_source: Annotated[ feedback_source_1.FeedbackSource, Field(description='Source of the performance data') ] status: Annotated[Status, Field(description='Processing status of the performance feedback')] submitted_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when feedback was submitted') ] applied_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when feedback was applied to optimization algorithms' ), ] = 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 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', ) feedback_id: Annotated[ str, Field(description='Unique identifier for this performance feedback submission') ] media_buy_id: Annotated[str, Field(description="Publisher's media buy identifier")] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)' ), ] = None creative_id: Annotated[ str | None, Field(description='Specific creative asset (if feedback is creative-specific)') ] = None measurement_period: Annotated[ MeasurementPeriod, Field(description='Time period for performance measurement') ] performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] metric_type: Annotated[ metric_type_1.MetricType, Field(description='The business metric being measured') ] feedback_source: Annotated[ feedback_source_1.FeedbackSource, Field(description='Source of the performance data') ] status: Annotated[Status, Field(description='Processing status of the performance feedback')] submitted_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when feedback was submitted') ] applied_at: Annotated[ AwareDatetime | None, Field( description='ISO 8601 timestamp when feedback was applied to optimization algorithms' ), ] = 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 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', ) placement_id: Annotated[ str, Field(description='Unique identifier for the placement within the product') ] name: Annotated[ str, Field( description="Human-readable name for the placement (e.g., 'Homepage Banner', 'Article Sidebar')" ), ] 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, ), ] = 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): 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, ), ] input: Annotated[ Input, Field( description='The input parameters that generated this preview variant. Echoes back the request input or shows defaults used.' ), ]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', ) request_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview request'), ] 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 creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets for the format.'), ] 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 template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = None 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 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 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 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 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', ) request_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview request'), ] 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 creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets for the format.'), ] 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 template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = None 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 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 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 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 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', ) 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, ), ] 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 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 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_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', ) 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, ), ] 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 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 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_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', ) 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' ), ] creative_id: Annotated[str | None, Field(description='Creative identifier for context')] = 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 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 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', ) response_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview response'), ] 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, ), ] 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 expires_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when preview links expire') ] 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 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', ) response_type: Annotated[ Literal['single'], Field(description='Discriminator indicating this is a single preview response'), ] 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, ), ] 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 expires_at: Annotated[ AwareDatetime, Field(description='ISO 8601 timestamp when preview links expire') ] 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 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', ) 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, ), ] 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_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', ) 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, ), ] 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_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', ) 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')] creative_id: Annotated[ str | None, Field(description='Creative identifier this variant belongs to') ] = None previews: Annotated[ list[Preview7], Field( description='Array of rendered pieces for this variant. Most formats render as a single piece.', min_length=1, ), ] 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 expires_at: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp when preview links expire') ] = None 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 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', ) render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] 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.' ), ] 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." ), ] 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'), ] = 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 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', ) render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] 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.' ), ] 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." ), ] dimensions: Annotated[ Dimensions | None, Field(description='Dimensions for this rendered piece') ] = None embedding: Annotated[ Embedding | None, Field(description='Optional security and embedding metadata') ] = 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 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', ) render_id: Annotated[ str, Field(description='Unique identifier for this rendered piece within the variant') ] output_format: Annotated[ Literal['both'], Field( description='Discriminator indicating both preview_url and preview_html are provided' ), ] preview_url: Annotated[ AnyUrl, Field( description='URL to an HTML page that renders this piece. Can be embedded in an iframe.' ), ] 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.' ), ] 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." ), ] 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'), ] = 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 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 Pricing (**data: Any)-
Expand source code
class Pricing(_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 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', ) product_id: Annotated[str, Field(description='Unique identifier for the product')] name: Annotated[str, Field(description='Human-readable product name')] description: Annotated[ str, Field(description='Detailed description of the product and its inventory') ] 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, ), ] 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 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' ), ] 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 delivery_type: delivery_type_1.DeliveryType 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 shows or placements." ), ] = None pricing_options: Annotated[ list[pricing_option.PricingOption], Field(description='Available pricing models for this product', min_length=1), ] 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 outcome_measurement: outcome_measurement_1.OutcomeMeasurement | None = 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 reporting_capabilities: reporting_capabilities_1.ReportingCapabilities | None = None creative_policy: creative_policy_1.CreativePolicy | None = None is_custom: Annotated[bool | None, Field(description='Whether this is a custom product')] = None 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 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 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 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 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 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 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 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 brief_relevance: Annotated[ str | None, Field( description='Explanation of why this product matches the brief (only included when brief is provided)' ), ] = None expires_at: Annotated[ AwareDatetime | None, Field(description='Expiration timestamp for custom products') ] = None 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 show_ids: Annotated[ list[str] | None, Field( description="References to shows in the response's top-level shows array. When present, the product covers inventory associated with these shows. A product can span multiple shows (e.g., a podcast network bundle)." ), ] = None episodes: Annotated[ list[episode.Episode] | None, Field( description='Specific episodes included in this product. Each episode references its parent show via show_id when the product spans multiple shows. When absent with show_ids present, the product covers the shows broadly (run-of-show).' ), ] = None 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 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 brief_relevance : str | Nonevar catalog_match : CatalogMatch | Nonevar catalog_types : list[CatalogType] | Nonevar channels : list[MediaChannel] | 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 episodes : list[Episode] | Nonevar exclusivity : Exclusivity | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar forecast : DeliveryForecast | Nonevar format_ids : list[FormatId]var is_custom : bool | Nonevar max_optimization_goals : int | 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 show_ids : list[str] | Nonevar signal_targeting_allowed : bool | None
Inherited members
class ProductCard (**data: Any)-
Expand source code
class ProductCard(AdCPBaseModel): title: Annotated[bound_value.A2UiBoundValue, Field(description='Product name')] price: Annotated[bound_value.A2UiBoundValue, Field(description='Price display string')] image: Annotated[bound_value.A2UiBoundValue | None, Field(description='Product image URL')] = ( None ) description: Annotated[ bound_value.A2UiBoundValue | None, Field(description='Product description') ] = None badge: Annotated[ bound_value.A2UiBoundValue | None, Field(description="Badge text (e.g., 'Best Seller')") ] = None ctaLabel: Annotated[ bound_value.A2UiBoundValue | None, Field(description='CTA button label') ] = None action: Action4 | 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 action : Action4 | Nonevar badge : A2UiBoundValue | Nonevar ctaLabel : A2UiBoundValue | Nonevar description : A2UiBoundValue | Nonevar image : A2UiBoundValue | Nonevar model_configvar price : A2UiBoundValuevar title : A2UiBoundValue
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', ) feed_url: Annotated[AnyUrl, Field(description='URL to product catalog feed')] feed_format: Annotated[FeedFormat | None, Field(description='Format of the product feed')] = ( None ) categories: Annotated[ list[str] | None, Field(description='Product categories available in the catalog') ] = None last_updated: Annotated[ AwareDatetime | None, Field(description='When the product catalog was last updated') ] = None update_frequency: Annotated[ UpdateFrequency | None, Field(description='How frequently the product catalog is updated') ] = None agentic_checkout: Annotated[ AgenticCheckout | None, Field(description='Agentic checkout endpoint configuration') ] = 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', ) delivery_type: delivery_type_1.DeliveryType | None = 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 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 format_types: Annotated[ list[format_category.FormatCategory] | None, Field(description='Filter by format types', min_length=1), ] = None format_ids: Annotated[ list[format_id.FormatId] | None, Field(description='Filter by specific format IDs', min_length=1), ] = None standard_formats_only: Annotated[ bool | None, Field(description='Only return products accepting IAB standard formats') ] = None min_exposures: Annotated[ int | None, Field(description='Minimum exposures/impressions needed for measurement validity', ge=1), ] = None start_date: Annotated[ date_aliased | None, Field( description='Campaign start date (ISO 8601 date format: YYYY-MM-DD) for availability checks' ), ] = None end_date: Annotated[ date_aliased | None, Field( description='Campaign end date (ISO 8601 date format: YYYY-MM-DD) for availability checks' ), ] = None budget_range: Annotated[ BudgetRange | BudgetRange1 | None, Field(description='Budget range to filter appropriate products'), ] = 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 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 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 channels: Annotated[ list[channels_1.MediaChannel] | None, Field( description="Filter by advertising channels (e.g., ['display', 'ctv', 'dooh'])", min_length=1, ), ] = None required_axe_integrations: Annotated[ list[AnyUrl] | None, Field( description='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, ), ] = 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 format_types : list[FormatCategory] | Nonevar is_fixed_price : bool | Nonevar metros : list[Metro] | Nonevar min_exposures : int | Nonevar model_configvar regions : list[Region] | Nonevar required_axe_integrations : list[pydantic.networks.AnyUrl] | 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 | None
Inherited members
class PromotedOfferings (**data: Any)-
Expand source code
class PromotedOfferings(_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 PromotedOfferingsAssetRequirements (**data: Any)-
Expand source code
class PromotedOfferingsAssetRequirements(_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 PromotedOfferingsRequirement (*args, **kwds)-
Expand source code
class PromotedOfferingsRequirement(str, _Enum): si_agent_url = "si_agent_url" offerings = "offerings" brand_logos = "brand.logos" brand_colors = "brand.colors" brand_tone = "brand.tone" brand_assets = "brand.assets" brand_product_catalog = "brand.product_catalog"str(object='') -> str str(bytes_or_buffer[, encoding[, errors]]) -> str
Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.str() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to 'strict'.
Ancestors
- builtins.str
- enum.Enum
Class variables
var brand_assetsvar brand_colorsvar brand_logosvar brand_product_catalogvar brand_tonevar offeringsvar si_agent_url
class PromotedProducts (**data: Any)-
Expand source code
class PromotedProducts(_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 Property (**data: Any)-
Expand source code
class Property(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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') ] name: Annotated[str, Field(description='Human-readable property name')] identifiers: Annotated[ list[Identifier], Field(description='Array of identifiers for this property', min_length=1) ] tags: Annotated[ list[property_tag.PropertyTag] | None, Field( description='Tags for categorization and grouping (e.g., network membership, content categories)' ), ] = 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 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).' ), ] = 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_show_id = 'spotify_show_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_show_idvar subdomainvar venue_id
class PropertyList (**data: Any)-
Expand source code
class PropertyList(AdCPBaseModel): model_config = ConfigDict( extra='forbid', ) list_id: Annotated[str, Field(description='Unique identifier for this property list')] name: Annotated[str, Field(description='Human-readable name for the list')] description: Annotated[str | None, Field(description="Description of the list's purpose")] = ( None ) principal: Annotated[ str | None, Field(description='Principal identity that owns this list') ] = None 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 filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Dynamic filters applied when resolving the list'), ] = 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 webhook_url: Annotated[ AnyUrl | None, Field(description='URL to receive notifications when the resolved list changes'), ] = 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 ) updated_at: Annotated[ AwareDatetime | None, Field(description='When the list was last modified') ] = None property_count: Annotated[ int | None, Field(description='Number of properties in the resolved list (at time of last resolution)'), ] = 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', ) event: Annotated[Literal['property_list_changed'], Field(description='The event type')] 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 change_summary: Annotated[ ChangeSummary | None, Field(description='Summary of changes to the resolved list') ] = None resolved_at: Annotated[AwareDatetime, Field(description='When the list was re-resolved')] cache_valid_until: Annotated[ AwareDatetime | None, Field(description='When the consumer should refresh from the governance agent'), ] = None signature: Annotated[ str, Field( description="Cryptographic signature of the webhook payload, signed with the agent's private key. Recipients MUST verify this signature." ), ] 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 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', ) 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 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 property_types: Annotated[ list[property_type.PropertyType] | None, Field(description='Filter to these property types', 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 exclude_identifiers: Annotated[ list[identifier.Identifier] | None, Field(description='Identifiers to always exclude from results', 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')] list_id: Annotated[ str, Field(description='Identifier for the property list within the agent', min_length=1) ] 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.' ), ] = 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 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'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 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', ) proposal_id: Annotated[ str, Field( description='Unique identifier for this proposal. Used to execute it via create_media_buy.' ), ] name: Annotated[str, Field(description='Human-readable name for this media plan proposal')] description: Annotated[ str | None, Field(description='Explanation of the proposal strategy and what it achieves') ] = None 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, ), ] expires_at: Annotated[ AwareDatetime | None, Field( description='When this proposal expires and can no longer be executed. After expiration, referenced products or pricing may no longer be available.' ), ] = None total_budget_guidance: Annotated[ TotalBudgetGuidance | None, Field(description='Optional budget guidance for this proposal') ] = None brief_alignment: Annotated[ str | None, Field(description='Explanation of how this proposal aligns with the campaign brief'), ] = 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 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 allocations : list[ProductAllocation]var brief_alignment : str | Nonevar description : str | Nonevar expires_at : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar forecast : DeliveryForecast | Nonevar model_configvar name : strvar proposal_id : strvar 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 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 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.' ), ] 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 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.' ), ] = None 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 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.' ), ]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 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', ) message: Annotated[str, Field(description='Human-readable summary')] 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)' ), ] = 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 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', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's media buy identifier", min_length=1) ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy", min_length=1) ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar measurement_period : DatetimeRangevar media_buy_id : str | Nonevar 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', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's media buy identifier", min_length=1) ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy", min_length=1) ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar measurement_period : DatetimeRangevar media_buy_id : str | Nonevar 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', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's media buy identifier", min_length=1) ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy", min_length=1) ] = None measurement_period: Annotated[ datetime_range.DatetimeRange, Field(description='Time period for performance measurement') ] performance_index: Annotated[ float, Field( description='Normalized performance score (0.0 = no value, 1.0 = expected, >1.0 = above expected)', ge=0.0, ), ] package_id: Annotated[ str | None, Field( description='Specific package within the media buy (if feedback is package-specific)', min_length=1, ), ] = None creative_id: Annotated[ str | None, Field( description='Specific creative asset (if feedback is creative-specific)', min_length=1 ), ] = None metric_type: Annotated[ metric_type_1.MetricType | None, Field(description='The business metric being measured') ] = metric_type_1.MetricType.overall_performance feedback_source: Annotated[ feedback_source_1.FeedbackSource | None, Field(description='Source of the performance data') ] = feedback_source_1.FeedbackSource.buyer_attribution 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar creative_id : str | Nonevar ext : ExtensionObject | Nonevar feedback_source : FeedbackSource | Nonevar measurement_period : DatetimeRangevar media_buy_id : str | Nonevar 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', ) success: Annotated[ Literal[True], Field(description='Whether the performance feedback was successfully received'), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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_configvar sandbox : bool | Nonevar success : Literal[True]
Inherited members
class ProvidePerformanceFeedbackErrorResponse (**data: Any)-
Expand source code
class ProvidePerformanceFeedbackResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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, ), ] 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 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', ) 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'), ] property_ids: Annotated[ list[property_id.PropertyId], Field(description="Specific property IDs from the publisher's adagents.json", 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 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', ) 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') ] 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, ), ]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): url: Annotated[AnyUrl, Field(description='Webhook endpoint URL for task status notifications')] 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 authentication: Annotated[ Authentication, Field(description='Authentication configuration for webhook delivery (A2A-compatible)'), ]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', ) total_matching: Annotated[ int | None, Field(description='Total number of tasks matching filters (across all pages)', ge=0), ] = None returned: Annotated[ int | None, Field(description='Number of tasks returned in this response', ge=0) ] = None domain_breakdown: Annotated[ DomainBreakdown | None, Field(description='Count of tasks by domain') ] = None status_breakdown: Annotated[ dict[str, int] | None, Field(description='Count of tasks by status') ] = None filters_applied: Annotated[ list[str] | None, Field(description='List of filters that were applied to the query') ] = None sort_applied: Annotated[ SortApplied | None, Field(description='Sort order that was 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 domain_breakdown : DomainBreakdown | Nonevar filters_applied : list[str] | Nonevar model_configvar returned : int | Nonevar sort_applied : SortApplied | Nonevar status_breakdown : dict[str, int] | Nonevar total_matching : int | None
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', ) scope: Annotated[ Literal['request'], Field( description='Change scoped to the overall request — direction for the selection as a whole.' ), ] 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, ), ]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', ) plan_id: Annotated[str, Field(description='The plan this outcome is for.')] 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 buyer_campaign_ref: Annotated[str, Field(description='Campaign identifier.')] outcome: Annotated[outcome_type.OutcomeType, Field(description='Outcome type.')] seller_response: Annotated[ SellerResponse | None, Field(description="The seller's full response. Required when outcome is 'completed'."), ] = 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'.") ] = 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 buyer_campaign_ref : strvar check_id : str | Nonevar delivery : Delivery | Nonevar error : Error | 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', ) outcome_id: Annotated[str, Field(description='Unique identifier for this outcome record.')] status: Annotated[ Status, Field( description="'accepted' means state updated with no issues. 'findings' means issues were detected." ), ] 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 plan_summary: Annotated[ PlanSummary | None, Field( description="Updated plan budget state. Present for 'completed' and 'failed' outcomes." ), ] = 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 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', ) 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. Use a UUID or other unique identifier. 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 and buyer_campaign_ref, allowing a single request to span multiple accounts and campaigns.', min_length=1, ), ] 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 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) ] 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 sandbox: Annotated[ bool | None, Field(description='When true, the account is a sandbox account and no billing occurred.'), ] = None 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 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_reporting_frequencies: Annotated[ list[reporting_frequency.ReportingFrequency], Field(description='Supported reporting frequency options', min_length=1), ] 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, ), ] 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'], ), ] supports_webhooks: Annotated[ bool, Field(description='Whether this product supports webhook-based reporting notifications'), ] 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'], ], ), ] 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_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_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_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_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_audience_breakdown: Annotated[ bool | None, Field( description='Whether this product supports audience segment breakdowns in delivery reporting (by_audience 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 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." ), ]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', ) start: Annotated[AwareDatetime, Field(description='ISO 8601 start timestamp')] end: Annotated[AwareDatetime, Field(description='ISO 8601 end 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', ) url: Annotated[AnyUrl, Field(description='Webhook endpoint URL for reporting notifications')] 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 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." ), ] = 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 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', ) 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 creative_manifest: Annotated[ creative_manifest_1.CreativeManifest, Field(description='Complete creative manifest with all required assets.'), ] inputs: Annotated[ list[Input4] | None, Field( description='Array of input sets for generating multiple preview variants', min_length=1 ), ] = None template_id: Annotated[ str | None, Field(description='Specific template ID for custom format rendering') ] = None 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 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 item_limit: Annotated[ int | None, Field(description='Maximum number of catalog items to render in this preview.', 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 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): previews: Annotated[ list[Preview5], Field(description='Array of preview variants for this creative', min_length=1), ] interactive_url: AnyUrl | None = None expires_at: Annotated[AwareDatetime, Field(description='When the preview URLs expire')]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): width: bool height: 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): success: Annotated[Literal[True], Field(description='Indicates this preview request succeeded')] creative_id: Annotated[ str, Field( description='ID of the creative this result corresponds to. Enables correlation when processing batch results.' ), ] response: Annotated[Response, Field(description='Preview data for successful requests')] errors: Annotated[ list[error.Error] | None, Field(description='Errors for failed requests', 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 creative_id : strvar errors : list[Error] | Nonevar model_configvar response : Responsevar success : Literal[True]
Inherited members
class Security (**data: Any)-
Expand source code
class Security(AdCPBaseModel): method: Annotated[ webhook_security_method.WebhookSecurityMethod, Field(description='Authentication method') ] hmac_header: Annotated[ str | None, Field(description="Header name for HMAC signature (e.g., 'X-Signature')") ] = None api_key_header: Annotated[ str | None, Field(description="Header name for API key (e.g., 'X-API-Key')") ] = 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 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', ) modalities: Annotated[ Modalities | None, Field(description='Interaction modalities supported') ] = None components: Annotated[Components | None, Field(description='Visual components supported')] = ( None ) commerce: Annotated[Commerce | None, Field(description='Commerce capabilities')] = None a2ui: Annotated[A2ui | None, Field(description='A2UI (Agent-to-UI) capabilities')] = None mcp_apps: Annotated[ bool | None, Field(description='Supports MCP Apps for rendering A2UI surfaces in iframes') ] = 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 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', ) offering_id: Annotated[ str, Field(description='Offering identifier from the catalog to get details for') ] 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 include_products: Annotated[ bool | None, Field(description='Whether to include matching products in the response') ] = False product_limit: Annotated[ int | None, Field(description='Maximum number of matching products to return', ge=1, le=50) ] = 5 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 : 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', ) available: Annotated[bool, Field(description='Whether the offering is currently available')] 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 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 checked_at: Annotated[ AwareDatetime | None, Field(description='When this offering information was retrieved') ] = None offering: Annotated[Offering | None, Field(description='Offering details')] = None matching_products: Annotated[ list[MatchingProduct] | None, Field( description='Products matching the request context. Only included if include_products was true.' ), ] = 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 unavailable_reason: Annotated[ str | None, Field( description="If not available, why (e.g., 'expired', 'sold_out', 'region_restricted')" ), ] = None alternative_offering_ids: Annotated[ list[str] | None, Field(description='Alternative offerings to consider if this one is unavailable'), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Errors during offering lookup') ] = 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 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', ) consent_granted: Annotated[bool, Field(description='Whether user consented to share identity')] consent_timestamp: Annotated[ AwareDatetime | None, Field(description='When consent was granted (ISO 8601)') ] = None consent_scope: Annotated[ list[ConsentScopeEnum] | None, Field(description='What data was consented to share') ] = 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)') ] = None anonymous_session_id: Annotated[ str | None, Field(description='Session ID for anonymous users (when consent_granted is false)'), ] = 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') ] identity: si_identity.SiIdentity media_buy_id: Annotated[ str | None, Field(description='AdCP media buy ID if session was triggered by advertising') ] = None placement: Annotated[ str | None, Field( description="Where this session was triggered (e.g., 'chatgpt_search', 'claude_chat')" ), ] = None offering_id: Annotated[ str | None, Field(description='Brand-specific offering identifier to apply') ] = None supported_capabilities: Annotated[ si_capabilities.SiCapabilities | None, Field(description='What capabilities the host supports'), ] = 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 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 : strvar ext : ExtensionObject | 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', ) session_id: Annotated[ str, Field(description='Unique session identifier for subsequent messages') ] response: Annotated[Response | None, Field(description="Brand agent's initial response")] = None negotiated_capabilities: Annotated[ si_capabilities.SiCapabilities | None, Field(description='Intersection of brand and host capabilities for this session'), ] = None errors: Annotated[ list[error.Error] | None, Field(description='Errors during session initiation') ] = 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 errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar model_configvar negotiated_capabilities : SiCapabilities | Nonevar response : Response | Nonevar session_id : str
Inherited members
class SiSendMessageRequest (**data: Any)-
Expand source code
class SiSendMessageRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) session_id: Annotated[str, Field(description='Active session identifier')] message: Annotated[str | None, Field(description="User's message to the brand agent")] = None action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = 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 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', ) session_id: Annotated[str, Field(description='Active session identifier')] message: Annotated[str | None, Field(description="User's message to the brand agent")] = None action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = 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 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', ) session_id: Annotated[str, Field(description='Active session identifier')] message: Annotated[str | None, Field(description="User's message to the brand agent")] = None action_response: Annotated[ ActionResponse | None, Field(description='Response to a previous action_button (e.g., user clicked checkout)'), ] = 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 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', ) session_id: Annotated[str, Field(description='Session identifier')] response: Annotated[Response | None, Field(description="Brand agent's response")] = 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 session_status: Annotated[SessionStatus, Field(description='Current session status')] handoff: Annotated[ Handoff | None, Field(description='Handoff request when session_status is pending_handoff') ] = None errors: list[error.Error] | 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 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 : SessionStatus
Inherited members
class SiTerminateSessionRequest (**data: Any)-
Expand source code
class SiTerminateSessionRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) session_id: Annotated[str, Field(description='Session identifier to terminate')] reason: Annotated[Reason, Field(description='Reason for termination')] termination_context: Annotated[ TerminationContext | None, Field(description='Context for the termination') ] = 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 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', ) session_id: Annotated[str, Field(description='Terminated session identifier')] terminated: Annotated[bool, Field(description='Whether session was successfully terminated')] acp_handoff: Annotated[ AcpHandoff | None, Field(description='ACP checkout handoff data (for handoff_transaction)') ] = None follow_up: Annotated[FollowUp | None, Field(description='Suggested follow-up actions')] = None errors: list[error.Error] | 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 acp_handoff : AcpHandoff | Nonevar errors : list[Error] | Nonevar ext : ExtensionObject | Nonevar follow_up : FollowUp | Nonevar model_configvar session_id : strvar terminated : bool
Inherited members
class SiUiElement (**data: Any)-
Expand source code
class SiUiElement(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) type: Annotated[Type, Field(description='Component type')] data: Annotated[dict[str, Any] | None, Field(description='Component-specific data')] = 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 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', ) 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_agent_segment_id: Annotated[ str, Field( description="Opaque identifier used for activation. This is the signals agent's internal segment ID." ), ] name: Annotated[str, Field(description='Human-readable signal name')] description: Annotated[str, Field(description='Detailed signal description')] value_type: Annotated[ signal_value_type.SignalValueType | None, Field(description="The data type of this signal's values (binary, categorical, numeric)"), ] = None 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 range: Annotated[ Range | None, Field(description="Valid range for numeric signals. Present when value_type is 'numeric'."), ] = None signal_type: Annotated[ signal_catalog_type.SignalCatalogType, Field(description='Catalog type of signal (marketplace, custom, owned)'), ] data_provider: Annotated[str, Field(description='Human-readable name of the data provider')] coverage_percentage: Annotated[ float, Field(description='Percentage of audience coverage', ge=0.0, le=100.0) ] deployments: Annotated[ list[deployment.Deployment], Field(description='Array of deployment targets') ] 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, ), ]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 : 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') ] 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, ), ] 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.' ), ] = 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 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', ) field: Annotated[Field1 | None, Field(description='Field to sort by')] = Field1.created_at direction: Annotated[ sort_direction.SortDirection | None, Field(description='Sort direction') ] = sort_direction.SortDirection.descBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot 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 : Field1 | Nonevar model_config
Inherited members
class SortApplied (**data: Any)-
Expand source code
class SortApplied(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) field: str direction: DirectionBase model for AdCP types with spec-compliant serialization.
Defaults to
extra='ignore'so that unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas setadditionalProperties: trueoverride this withextra='allow'in their ownmodel_config. Consumers who want strict validation can override withextra='forbid'.Create a new model by parsing and validating input data from keyword arguments.
Raises [
ValidationError][pydantic_core.ValidationError] if the input data cannot 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 : Directionvar field : strvar 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', ) processing: Annotated[ int | None, Field(description='Number of creatives being processed', ge=0) ] = None approved: Annotated[int | None, Field(description='Number of approved creatives', ge=0)] = None pending_review: Annotated[ int | None, Field(description='Number of creatives pending review', ge=0) ] = None rejected: Annotated[int | None, Field(description='Number of rejected creatives', ge=0)] = None archived: Annotated[int | None, Field(description='Number of archived 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) ] 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 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).' ), ] = None 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 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', ) dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = None accounts: Annotated[list[Account], Field(description='Results for each account processed')] 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 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', ) errors: Annotated[ list[error.Error], Field( description='Operation-level errors (e.g., authentication failure, service unavailable)', min_length=1, ), ] 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 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 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 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 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') ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) errors: Annotated[ list[error.Error], Field(description='Operation-level errors that prevented processing', min_length=1), ] 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 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', ) 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.).' ), ] = None 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_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.') ] 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 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 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 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.strict 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 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 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', ) dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = None 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." ), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) 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, ), ] 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 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', ) percentage: Annotated[ float | None, Field(description='Completion percentage (0-100)', ge=0.0, le=100.0) ] = 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 total_steps: Annotated[ int | None, Field(description='Total number of steps in the operation', ge=1) ] = None step_number: Annotated[int | None, Field(description='Current step number', ge=1)] = None 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 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 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 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.') ] creatives: Annotated[ list[creative_asset.CreativeAsset], Field( description='Array of creative assets to sync (create or update)', max_length=100, min_length=1, ), ] 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 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 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.', max_length=255, min_length=8, ), ] = None 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 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.strict 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 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 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', ) dry_run: Annotated[ bool | None, Field(description='Whether this was a dry run (no actual changes made)') ] = 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." ), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) 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, ), ] 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 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.') ] 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 delete_missing: Annotated[ bool | None, Field(description='When true, event sources not included in this sync will be removed'), ] = False 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 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', ) event_sources: Annotated[ list[EventSource], Field( description='Results for each event source, including both synced and seller-managed sources on the account' ), ] sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 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', ) errors: Annotated[ list[error.Error], Field(description='Operation-level errors that prevented processing', min_length=1), ] 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 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(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) name: Annotated[str, Field(description='Human-readable name for this tag')] description: Annotated[str, Field(description='Description of what this tag represents')]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 description : strvar model_configvar name : str
Inherited members
class TargetingOverlay (**data: Any)-
Expand source code
class TargetingOverlay(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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_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 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 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 axe_include_segment: Annotated[ str | None, Field(description='AXE segment ID to include for targeting') ] = None axe_exclude_segment: Annotated[ str | None, Field(description='AXE segment ID to exclude from targeting') ] = 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 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 frequency_cap: frequency_cap_1.FrequencyCap | None = 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 age_restriction: Annotated[ AgeRestriction | None, Field( description='Age restriction for compliance. Use for legal requirements (alcohol, gambling), not audience targeting.' ), ] = 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 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, ), ] = None geo_proximity: Annotated[ list[GeoProximity | GeoProximity2 | GeoProximity3] | 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 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 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 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, ), ] = 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 axe_exclude_segment : str | Nonevar axe_include_segment : 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 | GeoProximity2 | GeoProximity3] | 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
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[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[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[ActivateSignalResponse1, ActivateSignalResponse2]]
- adcp.types.core.TaskResult[Union[BuildCreativeResponse1, BuildCreativeResponse2, BuildCreativeResponse3]]
- adcp.types.core.TaskResult[Union[CalibrateContentResponse1, CalibrateContentResponse2]]
- 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[GetContentStandardsResponse1, GetContentStandardsResponse2]]
- adcp.types.core.TaskResult[Union[GetCreativeFeaturesResponse1, GetCreativeFeaturesResponse2]]
- adcp.types.core.TaskResult[Union[GetMediaBuyArtifactsResponse1, GetMediaBuyArtifactsResponse2]]
- 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['time'], Field(description='Cost per time unit - rate scales with campaign duration'), ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = None parameters: Annotated[Parameters, Field(description='Time-based pricing parameters')] 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar min_spend_per_package : float | Nonevar model_configvar parameters : Parametersvar 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 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', ) standards_id: Annotated[str, Field(description='ID of the standards configuration to update')] scope: Annotated[ Scope | None, Field(description='Updated scope for where this standards configuration applies'), ] = 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 policy: Annotated[ str | None, Field( description='Updated natural language policy describing acceptable and unacceptable content contexts.' ), ] = None 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 = 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 calibration_exemplars : CalibrationExemplars | Nonevar context : ContextObject | Nonevar ext : ExtensionObject | 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', ) success: Annotated[ Literal[True], Field(description='Indicates the update was applied successfully') ] standards_id: Annotated[str, Field(description='ID of the updated standards configuration')] 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_configvar standards_id : strvar success : Literal[True]
Inherited members
class UpdateContentStandardsErrorResponse (**data: Any)-
Expand source code
class UpdateContentStandardsResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) success: Annotated[Literal[False], Field(description='Indicates the update failed')] errors: Annotated[ list[error.Error], Field(description='Errors that occurred during the update', min_length=1) ] 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 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_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', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's ID of the media buy to update") ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy to update") ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None start_time: start_timing.StartTiming | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates', min_length=1), ] = 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 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 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.', max_length=255, min_length=8, ), ] = None 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar media_buy_id : str | Nonevar model_configvar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar start_time : StartTiming | None
class UpdateMediaBuyPackagesRequest (**data: Any)-
Expand source code
class UpdateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's ID of the media buy to update") ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy to update") ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None start_time: start_timing.StartTiming | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates', min_length=1), ] = 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 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 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.', max_length=255, min_length=8, ), ] = None 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar media_buy_id : str | Nonevar model_configvar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar start_time : StartTiming | None
class UpdateMediaBuyPropertiesRequest (**data: Any)-
Expand source code
class UpdateMediaBuyRequest(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) media_buy_id: Annotated[ str | None, Field(description="Publisher's ID of the media buy to update") ] = None buyer_ref: Annotated[ str | None, Field(description="Buyer's reference for the media buy to update") ] = None paused: Annotated[ bool | None, Field(description='Pause/resume the entire media buy (true = paused, false = active)'), ] = None start_time: start_timing.StartTiming | None = None end_time: Annotated[ AwareDatetime | None, Field(description='New end date/time in ISO 8601 format') ] = None packages: Annotated[ list[package_update.PackageUpdate] | None, Field(description='Package-specific updates', min_length=1), ] = 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 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 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.', max_length=255, min_length=8, ), ] = None 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 buyer_ref : str | Nonevar context : ContextObject | Nonevar end_time : pydantic.types.AwareDatetime | Nonevar ext : ExtensionObject | Nonevar idempotency_key : str | Nonevar media_buy_id : str | Nonevar model_configvar packages : list[PackageUpdate] | Nonevar paused : bool | Nonevar push_notification_config : PushNotificationConfig | Nonevar reporting_webhook : ReportingWebhook | Nonevar start_time : StartTiming | None
Inherited members
class UpdateMediaBuySuccessResponse (**data: Any)-
Expand source code
class UpdateMediaBuyResponse1(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) media_buy_id: Annotated[str, Field(description="Publisher's identifier for the media buy")] buyer_ref: Annotated[str, Field(description="Buyer's reference identifier for the media buy")] implementation_date: Annotated[ AwareDatetime | None, Field(description='ISO 8601 timestamp when changes take effect (null if pending approval)'), ] = None affected_packages: Annotated[ list[package.Package] | None, Field(description='Array of packages that were modified with complete state information'), ] = None sandbox: Annotated[ bool | None, Field(description='When true, this response contains simulated data from sandbox mode.'), ] = None 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 affected_packages : list[Package] | Nonevar buyer_ref : strvar context : ContextObject | Nonevar ext : ExtensionObject | Nonevar implementation_date : pydantic.types.AwareDatetime | Nonevar media_buy_id : strvar model_configvar sandbox : bool | None
Inherited members
class UpdateMediaBuyErrorResponse (**data: Any)-
Expand source code
class UpdateMediaBuyResponse2(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) errors: Annotated[ list[error.Error], Field(description='Array of errors explaining why the operation failed', min_length=1), ] 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 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', ) 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 description: Annotated[str | None, Field(description='New description')] = None 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 filters: Annotated[ property_list_filters.PropertyListFilters | None, Field(description='Complete replacement for the filters (not a patch)'), ] = None brand: Annotated[ brand_ref.BrandReference | None, Field( description='Update brand reference. Resolved to full brand identity at execution time.' ), ] = None webhook_url: Annotated[ AnyUrl | None, Field( description='Update the webhook URL for list change notifications (set to empty string to remove)' ), ] = None 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 base_properties : list[BasePropertySource] | Nonevar brand : BrandReference | Nonevar context : ContextObject | Nonevar description : str | Nonevar ext : ExtensionObject | Nonevar filters : PropertyListFilters | 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', ) list: Annotated[property_list.PropertyList, Field(description='The updated property list')] 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 ext : ExtensionObject | Nonevar list : PropertyListvar model_config
Inherited members
class UrlAsset (**data: Any)-
Expand source code
class UrlAsset(AdCPBaseModel): model_config = ConfigDict( extra='allow', ) 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)" ), ] = None 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' ), ] = 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): standards_id: Annotated[str, Field(description='Standards configuration to validate against')] records: Annotated[ list[Record], Field( description='Delivery records to validate (max 10,000)', max_length=10000, min_length=1 ), ] 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 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 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): summary: Annotated[Summary, Field(description='Summary counts across all records')] results: Annotated[list[Result], Field(description='Per-record evaluation results')] 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_configvar results : list[Result]var summary : Summary
Inherited members
class ValidateContentDeliveryErrorResponse (**data: Any)-
Expand source code
class ValidateContentDeliveryResponse2(AdCPBaseModel): errors: list[error.Error] 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 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', ) delivery_type: Annotated[ Literal['url'], Field(description='Discriminator indicating VAST is delivered via URL endpoint'), ] 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'), ] = None duration_ms: Annotated[ int | None, Field(description='Expected video duration in milliseconds (if known)', ge=0) ] = None tracking_events: Annotated[ list[vast_tracking_event.VastTrackingEvent] | None, Field(description='Tracking events supported by this VAST tag'), ] = None captions_url: Annotated[ AnyUrl | None, Field(description='URL to captions file (WebVTT, SRT, etc.)') ] = None audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = 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 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', ) delivery_type: Annotated[ Literal['inline'], Field(description='Discriminator indicating VAST is delivered as inline XML content'), ] content: Annotated[str, Field(description='Inline VAST XML content')] 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'), ] = None duration_ms: Annotated[ int | None, Field(description='Expected video duration in milliseconds (if known)', ge=0) ] = None tracking_events: Annotated[ list[vast_tracking_event.VastTrackingEvent] | None, Field(description='Tracking events supported by this VAST tag'), ] = None captions_url: Annotated[ AnyUrl | None, Field(description='URL to captions file (WebVTT, SRT, etc.)') ] = None audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = 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 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) pricing_option_id: Annotated[ str, Field(description='Unique identifier for this pricing option within the product') ] pricing_model: Annotated[ Literal['vcpm'], Field(description='Cost per 1,000 viewable impressions (MRC standard)') ] currency: Annotated[ str, Field( description='ISO 4217 currency code', examples=['USD', 'EUR', 'GBP', 'JPY'], pattern='^[A-Z]{3}$', ), ] 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 price_guidance: Annotated[ price_guidance_1.PriceGuidance | None, Field(description='Optional pricing guidance for auction-based bidding'), ] = 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, ), ] = 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 fixed_price : float | Nonevar floor_price : float | Nonevar max_bid : bool | Nonevar min_spend_per_package : float | Nonevar model_configvar 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', ) 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')"), ] = None 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) ] = 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', ) url: Annotated[AnyUrl, Field(description='URL to the video asset')] width: Annotated[int, Field(description='Width in pixels', ge=1)] height: Annotated[int, Field(description='Height in pixels', ge=1)] 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 container_format: Annotated[ str | None, Field(description='Video container format (mp4, webm, mov, etc.)') ] = None video_codec: Annotated[ str | None, Field(description='Video codec used (h264, h265, vp9, av1, prores, etc.)') ] = None video_bitrate_kbps: Annotated[ int | None, Field(description='Video stream bitrate in kilobits per second', 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 scan_type: Annotated[ScanType | None, Field(description='Scan type of the video')] = None color_space: Annotated[ColorSpace | None, Field(description='Color space of the video')] = None hdr_format: Annotated[ HdrFormat | None, Field(description="HDR format if applicable, or 'sdr' for standard dynamic range"), ] = None chroma_subsampling: Annotated[ ChromaSubsampling | None, Field(description='Chroma subsampling format') ] = None video_bit_depth: Annotated[VideoBitDepth | None, Field(description='Video bit depth')] = 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 moov_atom_position: Annotated[ MoovAtomPosition | None, Field(description='Position of moov atom in MP4 container') ] = None has_audio: Annotated[ bool | None, Field(description='Whether the video contains an audio track') ] = None audio_codec: Annotated[ str | None, Field(description='Audio codec used (aac, aac_lc, he_aac, pcm, mp3, ac3, eac3, etc.)'), ] = None audio_sampling_rate_hz: Annotated[ int | None, Field(description='Audio sampling rate in Hz (e.g., 44100, 48000)') ] = None audio_channels: Annotated[ AudioChannels | None, Field(description='Audio channel configuration') ] = None 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_loudness_lufs: Annotated[ float | None, Field(description='Integrated loudness in LUFS') ] = 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 transcript_url: Annotated[ AnyUrl | None, Field(description='URL to text transcript of the video content') ] = None audio_description_url: Annotated[ AnyUrl | None, Field(description='URL to audio description track for visually impaired users'), ] = 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 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', ) url: Annotated[AnyUrl, Field(description='Webhook URL to call for dynamic content')] method: Annotated[http_method.HttpMethod | None, Field(description='HTTP method')] = ( http_method.HttpMethod.POST ) timeout_ms: Annotated[ int | None, Field(description='Maximum time to wait for response in milliseconds', ge=10, le=5000), ] = 500 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 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')] 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 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