Module adcp.types.versioned_bases.v32

Generated lazy named extension bases for the pinned bundled schema.

Classes

class AcceptProposalInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class AcceptProposalRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : dict[str, typing.Any]

var adcp_major_version : int | None

var adcp_version : str | None

var budget_cap_timezone : str | None

var context : dict[str, typing.Any] | None

var daily_budget_cap : float | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var io_acceptance : adcp.types.versioned_bases._v32._AcceptProposalRequestBaseIoAcceptance | None

var model_config

var opportunity : adcp.types.versioned_bases._v32._AcceptProposalRequestBaseOpportunity | None

var proposal_id : str

var proposal_terms_digest : str

var purchase_order_ref : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v32._ExternalCoreReportingWebhook | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var total_budget : adcp.types.versioned_bases._v32._AcceptProposalRequestBaseTotalBudget | None

class AcceptProposalResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accepted_proposal : adcp.types.versioned_bases._v32._AcceptProposalResponseBaseAcceptedProposal | None

var available_actions : list[adcp.types.versioned_bases._v32._AcceptProposalResponseBaseAvailableActionsItemVariant1 | adcp.types.versioned_bases._v32._AcceptProposalResponseBaseAvailableActionsItemVariant2 | adcp.types.versioned_bases._v32._AcceptProposalResponseBaseAvailableActionsItemVariant3] | None

var confirmed_at : str | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var purchase_bindings : list[adcp.types.versioned_bases._v32._AcceptProposalResponseBasePurchaseBindingsItem] | None

var replayed : Literal[True] | None

var revision : int | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed'] | Literal['failed'] | Literal['submitted']

var task_id : str | None

var warnings : list[adcp.types.versioned_bases._v32._AcceptProposalResponseBaseWarningsItem] | None

class AcceptProposalSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class AcceptProposalWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class AcquireRightsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._AcquireRightsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._AcquireRightsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var buyer : adcp.types.versioned_bases._v32._ExternalCoreBrandRef

var campaign : adcp.types.versioned_bases._v32._AcquireRightsRequestBaseCampaign

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var model_config

var pricing_option_id : str

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var revocation_webhook : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig

var rights_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class AcquireRightsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var approval_webhook : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var brand_id : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var detail : str | None

var disclosure : adcp.types.versioned_bases._v32._AcquireRightsResponseBaseDisclosure | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var estimated_response_time : str | None

var ext : dict[str, typing.Any] | None

var generation_credentials : list[adcp.types.versioned_bases._v32._ExternalCoreGenerationCredential] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reason : str | None

var replayed : bool

var restrictions : list[str] | None

var rights_constraint : adcp.types.versioned_bases._v32._AcquireRightsResponseBaseRightsConstraint | None

var rights_id : str | None

var rights_status : Literal['acquired'] | Literal['pending_approval'] | Literal['rejected'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var suggestions : list[str] | None

var task_id : str | None

var terms : adcp.types.versioned_bases._v32._ExternalBrandRightsTerms | None

var timestamp : str | None

var usage_reporting_url : str | None

class ActivateSignalRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ActivateSignalRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ActivateSignalRequestBaseAccountVariant2 | None

var action : Literal['activate', 'deactivate']

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var destinations : list[adcp.types.versioned_bases._v32._ActivateSignalRequestBaseDestinationsItemVariant1 | adcp.types.versioned_bases._v32._ActivateSignalRequestBaseDestinationsItemVariant2]

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var model_config

var pricing_option_id : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signal_agent_segment_id : str

class ActivateSignalResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var deployments : list[adcp.types.versioned_bases._v32._ActivateSignalResponseBaseDeploymentsItemVariant1 | adcp.types.versioned_bases._v32._ActivateSignalResponseBaseDeploymentsItemVariant2] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class BuildCreativeInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['APPROVAL_REQUIRED', 'CREATIVE_DIRECTION_NEEDED', 'ASSET_SELECTION_NEEDED'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class BuildCreativeRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._BuildCreativeRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var concept_id : str | None

var config : dict[str, typing.Any] | None

var context : dict[str, typing.Any] | None

var creative_id : str | None

var creative_manifest : adcp.types.versioned_bases._v32._BuildCreativeRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseCreativeManifestVariant2 | None

var evaluator : adcp.types.versioned_bases._v32._BuildCreativeRequestBaseEvaluatorVariant1 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseEvaluatorVariant2 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseEvaluatorVariant3 | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var include_preview : bool | None

var item_limit : int | None

var keep_mode : Literal['keep_all', 'keep_one', 'keep_some']

var macro_values : dict[str, str] | None

var max_creatives : int | None

var max_spend : adcp.types.versioned_bases._v32._BuildCreativeRequestBaseMaxSpend | None

var max_variants : int

var media_buy_id : str | None

var message : str | None

var mode : Literal['execute', 'estimate']

var model_config

var package_id : str | None

var preview_inputs : list[adcp.types.versioned_bases._v32._BuildCreativeRequestBasePreviewInputsItem] | None

var preview_output_format : Literal['url', 'html']

var preview_quality : Literal['draft', 'production'] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var quality : Literal['draft', 'production'] | None

var refine_from_build_variant_id : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var selection_strategy : Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None

var signal_conditions : list[adcp.types.versioned_bases._v32._BuildCreativeRequestBaseSignalConditionsItemVariant1 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseSignalConditionsItemVariant2 | adcp.types.versioned_bases._v32._BuildCreativeRequestBaseSignalConditionsItemVariant3] | None

var target_capability_id : str | None

var target_capability_ids : list[str] | None

var target_format_id : adcp.types.versioned_bases._v32._ExternalCoreFormatId | None

var target_format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var transformer_id : str | None

var variant_axis : adcp.types.versioned_bases._v32._BuildCreativeRequestBaseVariantAxis | None

class BuildCreativeResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var budget_status : Literal['complete', 'capped']

var build_variant_id : str | None

var consumption : adcp.types.versioned_bases._v32._ExternalCoreCreativeConsumption | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_manifest : adcp.types.versioned_bases._v32._BuildCreativeResponseBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v32._BuildCreativeResponseBaseCreativeManifestVariant2 | None

var creative_manifests : list[adcp.types.versioned_bases._v32._BuildCreativeResponseBaseCreativeManifestsItemVariant1 | adcp.types.versioned_bases._v32._BuildCreativeResponseBaseCreativeManifestsItemVariant2] | None

var creatives : list[adcp.types.versioned_bases._v32._BuildCreativeResponseBaseCreativesItem] | None

var currency : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var estimate : adcp.types.versioned_bases._v32._BuildCreativeResponseBaseEstimate | None

var expires_at : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var items_returned : int | None

var items_total : int | None

var keep_mode_applied : Literal['keep_all', 'keep_one', 'keep_some'] | None

var leaves_returned : int | None

var leaves_total : int | None

var message : str | None

var mode : Literal['estimate'] | None

var model_config

var payload : dict[str, typing.Any] | None

var preview : adcp.types.versioned_bases._v32._BuildCreativeResponseBasePreview | adcp.types.versioned_bases._v32._BuildCreativeResponseBasePreview2 | None

var preview_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var pricing_option_id : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var recipe_hash : str | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var selection_strategy_applied : Literal['audience_relevance', 'contextual_fit', 'performance', 'proximity', 'inventory_priority', 'random'] | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

var vendor_cost : float | None

class BuildCreativeSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class BuildCreativeWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class BuyProductsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class BuyProductsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : dict[str, typing.Any]

var adcp_major_version : int | None

var adcp_version : str | None

var advertiser_industry : Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None

var agency_estimate_number : str | None

var bidding : adcp.types.versioned_bases._v32._ExternalCoreBiddingPolicy | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandKey | None

var budget_allocation : adcp.types.versioned_bases._v32._BuyProductsRequestBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._BuyProductsRequestBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var context : dict[str, typing.Any] | None

var daily_budget_cap : float | None

var end_time : str

var ext : dict[str, typing.Any] | None

var feed_version : str

var governance_context : str | None

var idempotency_key : str

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var model_config

var opportunity : adcp.types.versioned_bases._v32._BuyProductsRequestBaseOpportunity | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var paused : bool

var pricing_version : str | None

var purchase_order_ref : str | None

var purchases : list[adcp.types.versioned_bases._v32._ExternalMediaBuyProductPurchase]

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v32._ExternalCoreReportingWebhook | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_time : Literal['asap'] | str

var total_budget : adcp.types.versioned_bases._v32._BuyProductsRequestBaseTotalBudget | None

class BuyProductsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accepted_proposal : adcp.types.versioned_bases._v32._BuyProductsResponseBaseAcceptedProposal | None

var available_actions : list[adcp.types.versioned_bases._v32._BuyProductsResponseBaseAvailableActionsItemVariant1 | adcp.types.versioned_bases._v32._BuyProductsResponseBaseAvailableActionsItemVariant2 | adcp.types.versioned_bases._v32._BuyProductsResponseBaseAvailableActionsItemVariant3] | None

var confirmed_at : str | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var purchase_bindings : list[adcp.types.versioned_bases._v32._BuyProductsResponseBasePurchaseBindingsItem] | None

var replayed : Literal[True] | None

var revision : int | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed'] | Literal['failed'] | Literal['submitted']

var task_id : str | None

var warnings : list[adcp.types.versioned_bases._v32._BuyProductsResponseBaseWarningsItem] | None

class BuyProductsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class BuyProductsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class CalibrateContentRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var artifact : adcp.types.versioned_bases._v32._ExternalContentStandardsArtifact

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str

class CalibrateContentResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var confidence : float | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var explanation : str | None

var ext : dict[str, typing.Any] | None

var features : list[adcp.types.versioned_bases._v32._CalibrateContentResponseBaseFeaturesItem] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var verdict : Literal['pass', 'fail'] | None

class CheckGovernanceRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var caller : str

var consultation_context : str | None

var context : dict[str, typing.Any] | None

var delivery_metrics : adcp.types.versioned_bases._v32._CheckGovernanceRequestBaseDeliveryMetrics | None

var execution_commitment : adcp.types.versioned_bases._v32._CheckGovernanceRequestBaseExecutionCommitment | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var model_config

var modification_summary : str | None

var payload : dict[str, typing.Any] | None

var phase : Literal['purchase', 'modification', 'delivery']

var plan_id : str | None

var planned_delivery : adcp.types.versioned_bases._v32._ExternalCorePlannedDelivery | None

var proposal : adcp.types.versioned_bases._v32._ExternalCoreCanonicalProposal | None

var proposed_commitment : adcp.types.versioned_bases._v32._CheckGovernanceRequestBaseProposedCommitment | None

var purchase_type : Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']

var runtime_attestations : list[adcp.types.versioned_bases._v32._CheckGovernanceRequestBaseRuntimeAttestationsItem] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var target_agent : str | None

var tool : str | None

class CheckGovernanceResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var categories_evaluated : list[str] | None

var check_id : str

var check_type : Literal['intent', 'execution'] | None

var conditions : list[adcp.types.versioned_bases._v32._CheckGovernanceResponseBaseConditionsItem] | None

var consultation_context : str | None

var context : dict[str, typing.Any] | None

var delivery_statement : adcp.types.versioned_bases._v32._CheckGovernanceResponseBaseDeliveryStatement | None

var expires_at : str | None

var explanation : str

var ext : dict[str, typing.Any] | None

var findings : list[adcp.types.versioned_bases._v32._CheckGovernanceResponseBaseFindingsItem] | None

var governance_context : str | None

var mode : Literal['audit', 'advisory', 'enforce'] | None

var model_config

var next_check : str | None

var plan_id : str | None

var policies_evaluated : list[str] | None

var runtime_attestation_binding_digest : str | None

var runtime_attestation_evaluations : list[adcp.types.versioned_bases._v32._CheckGovernanceResponseBaseRuntimeAttestationEvaluationsItem] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var verdict : Literal['approved', 'denied', 'conditions']

class ComplyTestControllerRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ComplyTestControllerRequestBaseAccount

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var params : adcp.types.versioned_bases._v32._ComplyTestControllerRequestBaseParams | None

var scenario : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ComplyTestControllerResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var audit_observations : list[adcp.types.versioned_bases._v32._ExternalCreativeAuditObservation] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_id : str | None

var cumulative : dict[str, typing.Any] | None

var current_state : str | None

var error : Literal['INVALID_TRANSITION', 'INVALID_STATE', 'NOT_FOUND', 'UNKNOWN_SCENARIO', 'INVALID_PARAMS', 'FORBIDDEN', 'JCS_NON_FINITE_NUMBER', 'INTERNAL_ERROR'] | None

var error_detail : str | None

var ext : dict[str, typing.Any] | None

var forced : adcp.types.versioned_bases._v32._ComplyTestControllerResponseBaseForced | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var previous_state : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var recorded_calls : list[adcp.types.versioned_bases._v32._ComplyTestControllerResponseBaseRecordedCallsItemVariant1 | adcp.types.versioned_bases._v32._ComplyTestControllerResponseBaseRecordedCallsItemVariant2] | None

var replayed : bool

var scenarios : list[str] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var simulated : dict[str, typing.Any] | None

var since_timestamp : str | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var success : Literal[True] | Literal[False]

var task_id : str | None

var timestamp : str | None

var total_count : int | None

var truncated : bool | None

class ContextMatchRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var $schema : str | None

var adcp_major_version : int | None

var adcp_version : str | None

var artifact : adcp.types.versioned_bases._v32._ExternalContentStandardsArtifact | None

var artifact_refs : list[adcp.types.versioned_bases._v32._ContextMatchRequestBaseArtifactRefsItem] | None

var context_signals : adcp.types.versioned_bases._v32._ContextMatchRequestBaseContextSignals | None

var geo : adcp.types.versioned_bases._v32._ContextMatchRequestBaseGeo | None

var model_config

var package_ids : list[str] | None

var placement_id : str

var property_id : str | None

var property_rid : str

var property_type : Literal['website', 'mobile_app', 'ctv_app', 'desktop_app', 'dooh', 'podcast', 'radio', 'linear_tv', 'streaming_audio', 'ai_assistant']

var protocol_version : str

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var seller_agent_url : str

var type : Literal['context_match_request']

class ContextMatchResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var governance_context : str | None

var message : str | None

var model_config

var offers : list[adcp.types.versioned_bases._v32._ExternalTrustedMatchOffer]

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signals : adcp.types.versioned_bases._v32._ContextMatchResponseBaseSignals | None

var signals_by_provider : dict[str, adcp.types.versioned_bases._v32._ContextMatchResponseBaseSignalsByProviderValue] | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var type : Literal['context_match_response']

class ControlMediaBuyInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ControlMediaBuyRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : dict[str, typing.Any]

var adcp_major_version : int | None

var adcp_version : str | None

var bidding : adcp.types.versioned_bases._v32._ExternalCoreBiddingPolicy | None

var budget_allocation : adcp.types.versioned_bases._v32._ControlMediaBuyRequestBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._ControlMediaBuyRequestBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var canceled : Literal[True] | None

var cancellation_reason : str | None

var context : dict[str, typing.Any] | None

var daily_budget_cap : float | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var media_buy_id : str

var model_config

var name : str | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var packages : list[adcp.types.versioned_bases._v32._ExternalMediaBuyPackageControl] | None

var paused : bool | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v32._ExternalCoreReportingWebhook | None

var revision : int

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var total_budget : adcp.types.versioned_bases._v32._ControlMediaBuyRequestBaseTotalBudget | None

class ControlMediaBuyResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var affected_package_ids : list[str] | None

var available_actions : list[adcp.types.versioned_bases._v32._ControlMediaBuyResponseBaseAvailableActionsItemVariant1 | adcp.types.versioned_bases._v32._ControlMediaBuyResponseBaseAvailableActionsItemVariant2 | adcp.types.versioned_bases._v32._ControlMediaBuyResponseBaseAvailableActionsItemVariant3] | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var implementation_date : str | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var replayed : Literal[True] | None

var revision : int | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed'] | Literal['failed'] | Literal['submitted']

var task_id : str | None

var warnings : list[adcp.types.versioned_bases._v32._ControlMediaBuyResponseBaseWarningsItem] | None

class ControlMediaBuySubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class ControlMediaBuyWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class CreateCollectionListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._CreateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._CreateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_collections : list[adcp.types.versioned_bases._v32._CreateCollectionListRequestBaseBaseCollectionsItemVariant1 | adcp.types.versioned_bases._v32._CreateCollectionListRequestBaseBaseCollectionsItemVariant2 | adcp.types.versioned_bases._v32._CreateCollectionListRequestBaseBaseCollectionsItemVariant3] | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var description : str | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._ExternalCollectionCollectionListFilters | None

var idempotency_key : str

var model_config

var name : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class CreateCollectionListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var auth_token : str

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list : adcp.types.versioned_bases._v32._ExternalCollectionCollectionList

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class CreateContentStandardsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var calibration_exemplars : adcp.types.versioned_bases._v32._CreateContentStandardsRequestBaseCalibrationExemplars | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var policies : list[adcp.types.versioned_bases._v32._ExternalGovernancePolicyEntry] | None

var registry_policy_ids : list[str] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var scope : adcp.types.versioned_bases._v32._CreateContentStandardsRequestBaseScope

class CreateContentStandardsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var conflicting_standards_id : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class CreateMediaBuyInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['APPROVAL_REQUIRED', 'BUDGET_EXCEEDS_LIMIT'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class CreateMediaBuyRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var advertiser_industry : Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism'] | None

var agency_estimate_number : str | None

var artifact_webhook : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseArtifactWebhook | None

var bidding : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseBidding | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef

var budget_allocation : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var context : dict[str, typing.Any] | None

var daily_budget_cap : float | None

var end_time : str

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var io_acceptance : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseIoAcceptance | None

var model_config

var name : str | None

var opportunity : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseOpportunity | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var packages : list[adcp.types.versioned_bases._v32._ExternalMediaBuyPackageRequest] | None

var paused : bool

var plan_id : str | None

var po_number : str | None

var proposal_id : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v32._ExternalCoreReportingWebhook | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_time : Literal['asap'] | str

var total_budget : adcp.types.versioned_bases._v32._CreateMediaBuyRequestBaseTotalBudget | None

class CreateMediaBuyResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ExternalCoreAccount | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var available_actions : list[adcp.types.versioned_bases._v32._ExternalCoreMediaBuyAvailableAction] | None

var bidding : adcp.types.versioned_bases._v32._CreateMediaBuyResponseBaseBidding | None

var budget_allocation : adcp.types.versioned_bases._v32._CreateMediaBuyResponseBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._CreateMediaBuyResponseBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var confirmed_at : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_deadline : str | None

var currency : str | None

var daily_budget_cap : float | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var name : str | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var packages : list[adcp.types.versioned_bases._v32._ExternalCorePackage] | None

var payload : dict[str, typing.Any] | None

var planned_delivery : adcp.types.versioned_bases._v32._ExternalCorePlannedDelivery | None

var proposal_id : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var revision : int | None

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

var total_budget : float | None

var valid_actions : list[typing.Literal['pause', 'resume', 'cancel', 'update_name', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None

var warnings : list[adcp.types.versioned_bases._v32._ExternalCoreWarning] | None

class CreateMediaBuySubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class CreateMediaBuyWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class CreatePropertyListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._CreatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._CreatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_properties : list[adcp.types.versioned_bases._v32._CreatePropertyListRequestBaseBasePropertiesItemVariant1 | adcp.types.versioned_bases._v32._CreatePropertyListRequestBaseBasePropertiesItemVariant2 | adcp.types.versioned_bases._v32._CreatePropertyListRequestBaseBasePropertiesItemVariant3] | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var description : str | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._ExternalPropertyPropertyListFilters | None

var idempotency_key : str

var model_config

var name : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class CreatePropertyListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var auth_token : str

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list : adcp.types.versioned_bases._v32._ExternalPropertyPropertyList

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class CreativeApprovalRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var creative_format : adcp.types.versioned_bases._v32._ExternalCoreFormatId | None

var creative_id : str | None

var creative_url : str

var description : str | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var metadata : dict[str, typing.Any] | None

var model_config

var rights_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class CreativeApprovalResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var approval_status : Literal['approved'] | Literal['rejected'] | Literal['pending_review'] | None

var approved_at : str | None

var conditions : list[str] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_id : str | None

var creative_url : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var estimated_response_time : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reason : str | None

var replayed : bool

var rights_id : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var status_url : str | None

var suggestions : list[str] | None

var task_id : str | None

var timestamp : str | None

class DeclineProposalsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class DeclineProposalsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var declines : list[adcp.types.versioned_bases._v32._ExternalMediaBuyProposalDecline]

var governance_context : str | None

var idempotency_key : str

var model_config

var opportunity : adcp.types.versioned_bases._v32._ExternalCoreOpportunityContext | None

var push_notification_config : adcp.types.versioned_bases._v32._DeclineProposalsRequestBasePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class DeclineProposalsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var replayed : Literal[True] | None

var results : list[adcp.types.versioned_bases._v32._DeclineProposalsResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v32._DeclineProposalsResponseBaseResultsItemVariant2] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted'] | None

var task_id : str | None

class DeclineProposalsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class DeclineProposalsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class DeleteCollectionListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._DeleteCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._DeleteCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var list_id : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class DeleteCollectionListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var deleted : bool

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list_id : str

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class DeletePropertyListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._DeletePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._DeletePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var list_id : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class DeletePropertyListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var deleted : bool

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list_id : str

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetAccountFinancialsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetAccountFinancialsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetAccountFinancialsRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var period : adcp.types.versioned_bases._v32._ExternalCoreDateRange | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetAccountFinancialsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseAccountVariant2 | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var balance : adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseBalance | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var credit : adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseCredit | None

var currency : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var invoices : list[adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseInvoicesItem] | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var payment_status : Literal['current', 'past_due', 'suspended'] | None

var payment_terms : Literal['net_15', 'net_30', 'net_45', 'net_60', 'net_90', 'prepay'] | None

var period : adcp.types.versioned_bases._v32._ExternalCoreDateRange | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var spend : adcp.types.versioned_bases._v32._GetAccountFinancialsResponseBaseSpend | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var timezone : str | None

class GetAdcpCapabilitiesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var protocols : list[typing.Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative']] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetAdcpCapabilitiesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseAccount | None

var adcp : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseAdcp

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseBrand | None

var compliance_testing : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseComplianceTesting | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseCreative | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var experimental_features : list[str] | None

var ext : dict[str, typing.Any] | None

var extensions_supported : list[str] | None

var governance : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseGovernance | None

var governance_context : str | None

var identity : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseIdentity | None

var last_updated : str | None

var measurement : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseMeasurement | None

var measurement_gateway : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseMeasurementGateway | None

var media_buy : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseMediaBuy | None

var message : str | None

var model_config

var oauth : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseOauth | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var request_signing : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseRequestSigning | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signals : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseSignals | None

var specialisms : list[typing.Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', 'creative-transformers', 'governance-aware-seller', 'governance-delivery-monitor', 'governance-spend-authority', 'property-lists', 'sales-broadcast-tv', 'sales-catalog-driven', 'sales-guaranteed', 'sales-non-guaranteed', 'sales-proposal-mode', 'sales-social', 'signal-marketplace', 'signal-owned', 'signed-requests', 'sponsored-intelligence']] | None

var sponsored_intelligence : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseSponsoredIntelligence | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var supported_protocols : list[typing.Literal['media_buy', 'signals', 'governance', 'sponsored_intelligence', 'creative', 'brand', 'measurement']]

var task_id : str | None

var timestamp : str | None

var webhook_signing : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseWebhookSigning | None

var wholesale_feed_versioning : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseWholesaleFeedVersioning | None

var wholesale_feed_webhooks : adcp.types.versioned_bases._v32._GetAdcpCapabilitiesResponseBaseWholesaleFeedWebhooks | None

class GetBrandIdentityRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var brand_id : str

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var fields : list[typing.Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var use_case : str | None

class GetBrandIdentityResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var assets : list[adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseAssetsItem] | None

var available_fields : list[typing.Literal['description', 'industries', 'keller_type', 'logos', 'colors', 'fonts', 'visual_guidelines', 'tone', 'tagline', 'voice_synthesis', 'assets', 'rights']] | None

var brand_id : str | None

var colors : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseColors | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var description : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var fonts : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseFonts | None

var governance_context : str | None

var house : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseHouse | None

var industries : list[str] | None

var keller_type : Literal['master', 'sub_brand', 'endorsed', 'independent'] | None

var logos : list[adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseLogosItem] | None

var message : str | None

var model_config

var names : list[dict[str, str]] | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseRights | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var tagline : str | list[dict[str, str]] | None

var task_id : str | None

var timestamp : str | None

var tone : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseTone | None

var visual_guidelines : dict[str, typing.Any] | None

var voice_synthesis : adcp.types.versioned_bases._v32._GetBrandIdentityResponseBaseVoiceSynthesis | None

class GetCollectionListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var list_id : str

var model_config

var pagination : adcp.types.versioned_bases._v32._GetCollectionListRequestBasePagination | None

var resolve : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetCollectionListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_valid_until : str | None

var collections : list[adcp.types.versioned_bases._v32._GetCollectionListResponseBaseCollectionsItem] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var coverage_gaps : dict[str, list[adcp.types.versioned_bases._v32._GetCollectionListResponseBaseCoverageGapsValueItem]] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list : adcp.types.versioned_bases._v32._ExternalCollectionCollectionList

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var resolved_at : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetContentStandardsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str

class GetContentStandardsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var calibration_exemplars : adcp.types.versioned_bases._v32._GetContentStandardsResponseBaseCalibrationExemplars | None

var channels_any : list[typing.Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var countries_all : list[str] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var languages_any : list[str] | None

var message : str | None

var model_config

var name : str | None

var payload : dict[str, typing.Any] | None

var policies : list[adcp.types.versioned_bases._v32._ExternalGovernancePolicyEntry] | None

var pricing_options : list[adcp.types.versioned_bases._v32._GetContentStandardsResponseBasePricingOptionsItemVariant1 | adcp.types.versioned_bases._v32._GetContentStandardsResponseBasePricingOptionsItemVariant2 | adcp.types.versioned_bases._v32._GetContentStandardsResponseBasePricingOptionsItemVariant3 | adcp.types.versioned_bases._v32._GetContentStandardsResponseBasePricingOptionsItemVariant4 | adcp.types.versioned_bases._v32._GetContentStandardsResponseBasePricingOptionsItemVariant5] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetCreativeDeliveryRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetCreativeDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetCreativeDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var creative_ids : list[str] | None

var end_date : str | None

var ext : dict[str, typing.Any] | None

var max_variants : int | None

var media_buy_ids : list[str] | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_date : str | None

class GetCreativeDeliveryResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account_id : str | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creatives : list[adcp.types.versioned_bases._v32._GetCreativeDeliveryResponseBaseCreativesItem]

var currency : str

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var media_buy_id : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._GetCreativeDeliveryResponseBasePagination | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var reporting_period : adcp.types.versioned_bases._v32._GetCreativeDeliveryResponseBaseReportingPeriod

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetCreativeFeaturesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetCreativeFeaturesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetCreativeFeaturesRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var creative_manifest : adcp.types.versioned_bases._v32._GetCreativeFeaturesRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v32._GetCreativeFeaturesRequestBaseCreativeManifestVariant2

var ext : dict[str, typing.Any] | None

var feature_ids : list[str] | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetCreativeFeaturesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var audit_observations : list[adcp.types.versioned_bases._v32._ExternalCreativeAuditObservation] | None

var consumption : adcp.types.versioned_bases._v32._ExternalCoreCreativeConsumption | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var currency : str | None

var detail_url : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var pricing_option_id : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v32._ExternalCreativeCreativeFeatureResult] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var vendor_cost : float | None

class GetMediaBuyArtifactsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetMediaBuyArtifactsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetMediaBuyArtifactsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var failures_only : bool

var media_buy_id : str

var model_config

var package_ids : list[str] | None

var pagination : adcp.types.versioned_bases._v32._GetMediaBuyArtifactsRequestBasePagination | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var time_range : adcp.types.versioned_bases._v32._GetMediaBuyArtifactsRequestBaseTimeRange | None

class GetMediaBuyArtifactsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var artifacts : list[adcp.types.versioned_bases._v32._GetMediaBuyArtifactsResponseBaseArtifactsItem] | None

var collection_info : adcp.types.versioned_bases._v32._GetMediaBuyArtifactsResponseBaseCollectionInfo | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var media_buy_id : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetMediaBuyDeliveryRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetMediaBuyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetMediaBuyDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var attribution_window : adcp.types.versioned_bases._v32._GetMediaBuyDeliveryRequestBaseAttributionWindow | None

var context : dict[str, typing.Any] | None

var end_date : str | None

var ext : dict[str, typing.Any] | None

var include_package_daily_breakdown : bool

var include_window_breakdown : bool

var media_buy_ids : list[str] | None

var model_config

var reporting_dimensions : adcp.types.versioned_bases._v32._GetMediaBuyDeliveryRequestBaseReportingDimensions | None

var requested_metrics : list[typing.Literal['impressions', 'spend', 'clicks', 'ctr', 'views', 'completed_views', 'completion_rate', 'conversions', 'conversion_value', 'commissionable_value', 'roas', 'cost_per_acquisition', 'new_to_brand_rate', 'leads', 'reach', 'frequency', 'grps', 'engagements', 'engagement_rate', 'follows', 'saves', 'profile_visits', 'viewability', 'viewable_rate', 'viewable_impressions', 'measurable_impressions', 'viewed_seconds', 'quartile_data', 'quartile_25', 'quartile_50', 'quartile_75', 'quartile_100', 'time_based_views', 'dooh_metrics', 'cost_per_click', 'cost_per_completed_view', 'cpm', 'downloads', 'units_sold', 'new_to_brand_units', 'plays', 'incremental_sales_lift', 'brand_lift', 'foot_traffic', 'conversion_lift', 'brand_search_lift']] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_date : str | None

var status_filter : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | list[typing.Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None

var time_granularity : Literal['hourly', 'daily', 'weekly', 'monthly', 'quarterly', 'post_campaign'] | None

class GetMediaBuyDeliveryResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var aggregated_totals : adcp.types.versioned_bases._v32._GetMediaBuyDeliveryResponseBaseAggregatedTotals | None

var attribution_window : adcp.types.versioned_bases._v32._ExternalCoreAttributionWindow | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var currency : str

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var media_buy_deliveries : list[adcp.types.versioned_bases._v32._GetMediaBuyDeliveryResponseBaseMediaBuyDeliveriesItem]

var message : str | None

var model_config

var next_expected_at : str | None

var notification_type : Literal['scheduled', 'final', 'delayed', 'adjusted', 'window_update'] | None

var partial_data : bool | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var reporting_period : adcp.types.versioned_bases._v32._GetMediaBuyDeliveryResponseBaseReportingPeriod

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sequence_number : int | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var unavailable_count : int | None

class GetMediaBuysRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetMediaBuysRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetMediaBuysRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_history : int

var include_snapshot : bool

var include_webhook_activity : bool

var indicator_types : list[typing.Literal['creative_fatigue', 'creative_quality_opportunity', 'creative_diversity_low', 'audience_saturation', 'inventory_shortfall_forecast', 'pacing_risk', 'budget_constrained']] | None

var media_buy_ids : list[str] | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status_filter : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | list[typing.Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled']] | None

var webhook_activity_limit : int

class GetMediaBuysResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var media_buys : list[adcp.types.versioned_bases._v32._GetMediaBuysResponseBaseMediaBuysItem]

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetPlanAuditLogsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var governance_contexts : list[str] | None

var include_entries : bool

var model_config

var plan_ids : list[str] | None

var portfolio_plan_ids : list[str] | None

var purchase_types : list[typing.Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetPlanAuditLogsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var plans : list[adcp.types.versioned_bases._v32._GetPlanAuditLogsResponseBasePlansItem]

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetProductsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var partial_results : list[adcp.types.versioned_bases._v32._ExternalCoreProduct] | None

var reason : Literal['CLARIFICATION_NEEDED', 'BUDGET_REQUIRED'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var suggestions : list[str] | None

class GetProductsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetProductsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetProductsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var brief : str | None

var buying_mode : Literal['brief', 'wholesale', 'refine']

var catalog : adcp.types.versioned_bases._v32._ExternalCoreCatalog | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var fields : list[typing.Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_ids', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', 'included_signals', 'signal_targeting_allowed', 'signal_targeting_options', 'signal_targeting_rules', 'demographic_targeting', 'overlay_support', 'targeting_resolution', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'is_custom', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] | None

var filters : adcp.types.versioned_bases._v32._ExternalCoreProductFilters | None

var idempotency_key : str | None

var if_pricing_version : str | None

var if_wholesale_feed_version : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var preferred_delivery_types : list[typing.Literal['guaranteed', 'non_guaranteed']] | None

var property_list : adcp.types.versioned_bases._v32._ExternalCorePropertyListRef | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var refine : list[adcp.types.versioned_bases._v32._GetProductsRequestBaseRefineItemVariant1 | adcp.types.versioned_bases._v32._GetProductsRequestBaseRefineItemVariant2 | adcp.types.versioned_bases._v32._GetProductsRequestBaseRefineItemVariant3] | None

var required_overlay_support : adcp.types.versioned_bases._v32._ExternalCoreTargetingOverlayRequirements | None

var required_policies : list[str] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var targeting_overlay : adcp.types.versioned_bases._v32._ExternalCoreTargeting | None

var time_budget : adcp.types.versioned_bases._v32._GetProductsRequestBaseTimeBudget | None

class GetProductsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_scope : Literal['public', 'account'] | None

var catalog_applied : bool | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var extensions : dict[str, typing.Any] | None

var filter_diagnostics : adcp.types.versioned_bases._v32._GetProductsResponseBaseFilterDiagnostics | None

var governance_context : str | None

var incomplete : list[adcp.types.versioned_bases._v32._GetProductsResponseBaseIncompleteItem] | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var pricing_version : str | None

var products : list[adcp.types.versioned_bases._v32._ExternalCoreProduct] | None

var property_list_applied : bool | None

var proposals : list[adcp.types.versioned_bases._v32._ExternalCoreProposal] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reason : str | None

var refinement_applied : list[adcp.types.versioned_bases._v32._GetProductsResponseBaseRefinementAppliedItemVariant1 | adcp.types.versioned_bases._v32._GetProductsResponseBaseRefinementAppliedItemVariant2 | adcp.types.versioned_bases._v32._GetProductsResponseBaseRefinementAppliedItemVariant3] | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var suggestions : list[str] | None

var targeting_resolution : adcp.types.versioned_bases._v32._ExternalMediaBuyGetProductsTargetingResolution | None

var task_id : str | None

var timestamp : str | None

var unchanged : Literal[True] | None

var wholesale_feed_version : str | None

class GetProductsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var estimated_completion : str | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class GetProductsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class GetPropertyListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetPropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetPropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var list_id : str

var model_config

var pagination : adcp.types.versioned_bases._v32._GetPropertyListRequestBasePagination | None

var resolve : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class GetPropertyListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_valid_until : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var coverage_gaps : dict[str, list[adcp.types.versioned_bases._v32._ExternalCoreIdentifier]] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var identifiers : list[adcp.types.versioned_bases._v32._ExternalCoreIdentifier] | None

var list : adcp.types.versioned_bases._v32._ExternalPropertyPropertyList

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var resolved_at : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetRightsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var brand_id : str | None

var buyer_brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var countries : list[str] | None

var ext : dict[str, typing.Any] | None

var include_excluded : bool

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var query : str

var right_type : Literal['talent', 'character', 'brand_ip', 'music', 'stock_media'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var uses : list[typing.Literal['likeness', 'voice', 'name', 'endorsement', 'motion_capture', 'signature', 'catchphrase', 'sync', 'background_music', 'editorial', 'commercial', 'ai_generated_image']]

class GetRightsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var excluded : list[adcp.types.versioned_bases._v32._GetRightsResponseBaseExcludedItem] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights : list[adcp.types.versioned_bases._v32._GetRightsResponseBaseRightsItem] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class GetSignalsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetSignalsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetSignalsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var countries : list[str] | None

var destinations : list[adcp.types.versioned_bases._v32._GetSignalsRequestBaseDestinationsItemVariant1 | adcp.types.versioned_bases._v32._GetSignalsRequestBaseDestinationsItemVariant2] | None

var discovery_mode : Literal['brief', 'wholesale']

var ext : dict[str, typing.Any] | None

var fields : list[typing.Literal['signal_ref', 'signal_id', 'signal_agent_segment_id', 'name', 'description', 'value_type', 'categories', 'range', 'demographic_predicate', 'signal_type', 'data_provider', 'coverage_percentage', 'deployments', 'pricing_options', 'taxonomy', 'data_sources', 'methodology', 'segmentation_criteria', 'criteria_url', 'refresh_cadence', 'lookback_window', 'onboarder', 'modeling', 'audience_expansion', 'device_expansion', 'countries', 'consent_basis', 'restricted_attributes', 'policy_categories', 'art9_basis', 'data_subject_rights', 'last_updated']] | None

var filters : adcp.types.versioned_bases._v32._ExternalCoreSignalFilters | None

var if_pricing_version : str | None

var if_wholesale_feed_version : str | None

var max_results : int | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signal_ids : list[adcp.types.versioned_bases._v32._GetSignalsRequestBaseSignalIdsItemVariant1 | adcp.types.versioned_bases._v32._GetSignalsRequestBaseSignalIdsItemVariant2] | None

var signal_refs : list[adcp.types.versioned_bases._v32._GetSignalsRequestBaseSignalRefsItemVariant1 | adcp.types.versioned_bases._v32._GetSignalsRequestBaseSignalRefsItemVariant2 | adcp.types.versioned_bases._v32._GetSignalsRequestBaseSignalRefsItemVariant3] | None

var signal_spec : str | None

class GetSignalsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_scope : Literal['public', 'account'] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var incomplete : list[adcp.types.versioned_bases._v32._GetSignalsResponseBaseIncompleteItem] | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var pricing_version : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signals : list[adcp.types.versioned_bases._v32._GetSignalsResponseBaseSignalsItem] | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var unchanged : Literal[True] | None

var wholesale_feed_version : str | None

class GetSignalsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var estimated_completion : str | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class GetSignalsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class GetTaskStatusRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._GetTaskStatusRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._GetTaskStatusRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_history : bool

var include_result : bool

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var task_id : str

class GetTaskStatusResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var completed_at : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var created_at : str

var error : adcp.types.versioned_bases._v32._GetTaskStatusResponseBaseError | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var has_webhook : bool | None

var history : list[adcp.types.versioned_bases._v32._GetTaskStatusResponseBaseHistoryItem] | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var progress : adcp.types.versioned_bases._v32._GetTaskStatusResponseBaseProgress | None

var protocol : Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var result : dict[str, typing.Any] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str

var task_type : Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']

var timestamp : str | None

var updated_at : str

class IdentityMatchRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var $schema : str | None

var adcp_major_version : int | None

var adcp_version : str | None

var consent : adcp.types.versioned_bases._v32._IdentityMatchRequestBaseConsent | None

var country : str | None

var identities : list[adcp.types.versioned_bases._v32._IdentityMatchRequestBaseIdentitiesItem]

var model_config

var package_ids : list[str] | None

var protocol_version : str

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sealed_credentials : list[adcp.types.versioned_bases._v32._IdentityMatchRequestBaseSealedCredentialsItem] | None

var seller_agent_url : str

var type : Literal['identity_match_request']

class IdentityMatchResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var eligible_package_ids : list[str]

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var serve_window_sec : int

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var tmpx : str | None

var tmpx_providers : dict[str, adcp.types.versioned_bases._v32._IdentityMatchResponseBaseTmpxProvidersValue] | None

var type : Literal['identity_match_response']

class ListAccountsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListAccountsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListAccountsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_webhook_activity : bool

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['active', 'pending_approval', 'rejected', 'payment_required', 'suspended', 'closed'] | None

var webhook_activity_limit : int

class ListAccountsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.versioned_bases._v32._ExternalCoreAccountWithAuthorization]

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ListCollectionListsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListCollectionListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListCollectionListsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var name_contains : str | None

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ListCollectionListsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var lists : list[adcp.types.versioned_bases._v32._ExternalCollectionCollectionList]

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ListContentStandardsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var channels : list[typing.Literal['display', 'olv', 'social', 'search', 'ctv', 'linear_tv', 'radio', 'streaming_audio', 'podcast', 'dooh', 'ooh', 'print', 'cinema', 'email', 'gaming', 'retail_media', 'influencer', 'affiliate', 'product_placement', 'sponsored_intelligence']] | None

var context : dict[str, typing.Any] | None

var countries : list[str] | None

var ext : dict[str, typing.Any] | None

var languages : list[str] | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ListContentStandardsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards : list[adcp.types.versioned_bases._v32._ExternalContentStandardsContentStandards] | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ListCreativeFormatsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListCreativeFormatsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListCreativeFormatsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var asset_types : list[typing.Literal['image', 'video', 'audio', 'text', 'markdown', 'html', 'css', 'javascript', 'zip', 'vast', 'daast', 'url', 'webhook', 'brief', 'catalog', 'published_post']] | None

var context : dict[str, typing.Any] | None

var disclosure_persistence : list[typing.Literal['continuous', 'initial', 'flexible']] | None

var disclosure_positions : list[typing.Literal['prominent', 'footer', 'audio', 'subtitle', 'overlay', 'end_card', 'pre_roll', 'companion']] | None

var ext : dict[str, typing.Any] | None

var format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var include_pricing : bool

var input_format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var is_responsive : bool | None

var max_height : int | None

var max_width : int | None

var min_height : int | None

var min_width : int | None

var model_config

var name_search : str | None

var output_format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var type : Literal['audio', 'video', 'display', 'dooh'] | None

var wcag_level : Literal['A', 'AA', 'AAA'] | None

class ListCreativeFormatsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_agents : list[adcp.types.versioned_bases._v32._ListCreativeFormatsResponseBaseCreativeAgentsItem] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var formats : list[adcp.types.versioned_bases._v32._ExternalCoreFormat]

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ListCreativesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListCreativesRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var assignment_limit : int

var assignment_projection : Literal['all', 'matching']

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var fields : list[typing.Literal['creative_id', 'name', 'format_id', 'format_kind', 'format_option_ref', 'assets', 'status', 'created_date', 'updated_date', 'tags', 'rights', 'rights_attestation_evaluations', 'localization', 'localization_unavailable', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] | None

var filters : adcp.types.versioned_bases._v32._ExternalCoreCreativeFilters | None

var include_assignments : bool

var include_items : bool

var include_pricing : bool

var include_purged : bool

var include_snapshot : bool

var include_variables : bool

var include_webhook_activity : bool

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sort : adcp.types.versioned_bases._v32._ListCreativesRequestBaseSort | None

var webhook_activity_limit : int

class ListCreativesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creatives : list[adcp.types.versioned_bases._v32._ListCreativesResponseBaseCreativesItemVariant1 | adcp.types.versioned_bases._v32._ListCreativesResponseBaseCreativesItemVariant2]

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var format_summary : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var query_summary : adcp.types.versioned_bases._v32._ListCreativesResponseBaseQuerySummary

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var status_summary : adcp.types.versioned_bases._v32._ListCreativesResponseBaseStatusSummary | None

var task_id : str | None

var timestamp : str | None

class ListProductsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : dict[str, typing.Any] | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandKey | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var criteria : adcp.types.versioned_bases._v32._ExternalMediaBuyProductDiscoveryCriteria | None

var cursor : str | None

var fields : list[typing.Literal['product_id', 'name', 'description', 'publisher_properties', 'channels', 'video_placement_types', 'audio_distribution_types', 'sponsored_placement_types', 'social_placement_surfaces', 'format_options', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'reporting_capabilities', 'measurement_terms', 'performance_standards', 'catalog_types', 'signal_targeting_allowed', 'signal_targeting_rules', 'demographic_targeting', 'audience_evidence', 'audience_evidence_selections', 'max_optimization_goals', 'catalog_match', 'brief_relevance', 'expires_at', 'allowed_actions']] | None

var governance_context : str | None

var idempotency_key : str | None

var if_feed_version : str | None

var if_pricing_version : str | None

var max_results : int

var model_config

var push_notification_config : adcp.types.versioned_bases._v32._ListProductsRequestBasePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ListProductsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var cache_scope : Literal['public', 'account']

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var feed_version : str

var incomplete : list[adcp.types.versioned_bases._v32._ListProductsResponseBaseIncompleteItem] | None

var model_config

var next_cursor : str | None

var outcome : Literal['listed'] | Literal['unchanged']

var pricing_version : str | None

var products : list[adcp.types.versioned_bases._v32._ExternalCoreCanonicalProduct] | None

var replayed : Literal[True] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ListPropertyListsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListPropertyListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListPropertyListsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var name_contains : str | None

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ListPropertyListsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var lists : list[adcp.types.versioned_bases._v32._ExternalPropertyPropertyList]

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ListTasksRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListTasksRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListTasksRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._ListTasksRequestBaseFilters | None

var include_history : bool

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sort : adcp.types.versioned_bases._v32._ListTasksRequestBaseSort | None

class ListTasksResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var query_summary : adcp.types.versioned_bases._v32._ListTasksResponseBaseQuerySummary

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var tasks : list[adcp.types.versioned_bases._v32._ListTasksResponseBaseTasksItem]

var timestamp : str | None

class ListTransformersRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ListTransformersRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ListTransformersRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var brief : str | None

var context : dict[str, typing.Any] | None

var expand_pagination : list[adcp.types.versioned_bases._v32._ListTransformersRequestBaseExpandPaginationItem] | None

var expand_params : list[str] | None

var ext : dict[str, typing.Any] | None

var include_pricing : bool

var input_format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var input_format_kinds : list[typing.Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'seller_rendered_stateful_display', 'coordinated_placements', 'custom']] | None

var model_config

var name_search : str | None

var output_capability_ids : list[str] | None

var output_format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var transformer_ids : list[str] | None

class ListTransformersResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var transformers : list[adcp.types.versioned_bases._v32._ExternalCoreTransformer]

class LogEventRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var event_source_id : str

var events : list[adcp.types.versioned_bases._v32._ExternalCoreEvent]

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var test_event_code : str | None

class LogEventResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var events_processed : int | None

var events_received : int | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var match_quality : float | None

var message : str | None

var model_config

var partial_failures : list[adcp.types.versioned_bases._v32._LogEventResponseBasePartialFailuresItem] | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var warnings : list[str] | None

class MediaBuyCommitmentResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accepted_proposal : adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBaseAcceptedProposal | None

var available_actions : list[adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBaseAvailableActionsItemVariant1 | adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBaseAvailableActionsItemVariant2 | adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBaseAvailableActionsItemVariant3] | None

var confirmed_at : str | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var purchase_bindings : list[adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBasePurchaseBindingsItem] | None

var replayed : Literal[True] | None

var revision : int | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed'] | Literal['failed'] | Literal['submitted']

var task_id : str | None

var warnings : list[adcp.types.versioned_bases._v32._MediaBuyCommitmentResponseBaseWarningsItem] | None

class PackageRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var agency_estimate_number : str | None

var audience_evidence_pins : list[adcp.types.versioned_bases._v32._ExternalCoreAudienceEvidencePin] | None

var audience_evidence_requirements : adcp.types.versioned_bases._v32._ExternalCoreAudienceEvidenceRequirements | None

var bid_price : float | None

var bidding : adcp.types.versioned_bases._v32._PackageRequestBaseBidding | None

var budget : float | None

var catalogs : list[adcp.types.versioned_bases._v32._ExternalCoreCatalog] | None

var committed_metrics : list[adcp.types.versioned_bases._v32._PackageRequestBaseCommittedMetricsItemVariant1 | adcp.types.versioned_bases._v32._PackageRequestBaseCommittedMetricsItemVariant2] | None

var context : dict[str, typing.Any] | None

var creative_assignments : list[adcp.types.versioned_bases._v32._ExternalCoreCreativeAssignment] | None

var creatives : list[adcp.types.versioned_bases._v32._PackageRequestBaseCreativesItemVariant1 | adcp.types.versioned_bases._v32._PackageRequestBaseCreativesItemVariant2] | None

var daily_budget_cap : float | None

var end_time : str | None

var ext : dict[str, typing.Any] | None

var format_ids : list[adcp.types.versioned_bases._v32._ExternalCoreFormatId] | None

var format_kind : Literal['image', 'html5', 'display_tag', 'image_carousel', 'video_hosted', 'video_vast', 'audio_hosted', 'audio_daast', 'sponsored_placement', 'native_in_feed', 'responsive_creative', 'agent_placement', 'seller_rendered_stateful_display', 'coordinated_placements', 'custom'] | None

var format_option_refs : list[adcp.types.versioned_bases._v32._PackageRequestBaseFormatOptionRefsItemVariant1 | adcp.types.versioned_bases._v32._PackageRequestBaseFormatOptionRefsItemVariant2] | None

var impressions : float | None

var measurement_terms : adcp.types.versioned_bases._v32._ExternalCoreMeasurementTerms | None

var min_spend_target : float | None

var model_config

var optimization_goals : list[adcp.types.versioned_bases._v32._PackageRequestBaseOptimizationGoalsItemVariant1 | adcp.types.versioned_bases._v32._PackageRequestBaseOptimizationGoalsItemVariant2 | adcp.types.versioned_bases._v32._PackageRequestBaseOptimizationGoalsItemVariant3] | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var params : dict[str, typing.Any] | None

var paused : bool

var performance_standards : list[adcp.types.versioned_bases._v32._ExternalCorePerformanceStandard] | None

var pricing_option_id : str

var product_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_time : str | None

var targeting_overlay : adcp.types.versioned_bases._v32._ExternalCoreTargeting | None

class PreviewCreativeRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var allow_async : bool

var context : dict[str, typing.Any] | None

var creative_id : str | None

var creative_manifest : adcp.types.versioned_bases._v32._PreviewCreativeRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v32._PreviewCreativeRequestBaseCreativeManifestVariant2 | None

var ext : dict[str, typing.Any] | None

var format_id : adcp.types.versioned_bases._v32._ExternalCoreFormatId | None

var inputs : list[adcp.types.versioned_bases._v32._PreviewCreativeRequestBaseInputsItem] | None

var item_limit : int | None

var model_config

var output_format : Literal['url', 'html']

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var quality : Literal['draft', 'production'] | None

var request_type : Literal['single', 'batch', 'variant']

var requests : list[adcp.types.versioned_bases._v32._PreviewCreativeRequestBaseRequestsItem] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var target_capability_id : str | None

var template_id : str | None

var variant_id : str | None

class PreviewCreativeResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creative_id : str | None

var expires_at : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var interactive_url : str | None

var manifest : adcp.types.versioned_bases._v32._PreviewCreativeResponseBaseManifestVariant1 | adcp.types.versioned_bases._v32._PreviewCreativeResponseBaseManifestVariant2 | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var previews : list[adcp.types.versioned_bases._v32._PreviewCreativeResponseBasePreviewsItem] | list[adcp.types.versioned_bases._v32._PreviewCreativeResponseBasePreviewsItem2] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var quality_used : Literal['draft', 'production'] | None

var replayed : bool

var response_type : Literal['single'] | Literal['batch'] | Literal['variant'] | Literal['submitted']

var results : list[adcp.types.versioned_bases._v32._PreviewCreativeResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v32._PreviewCreativeResponseBaseResultsItemVariant2] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

var variant_id : str | None

class ProvidePerformanceFeedbackRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var as_of : str | None

var baseline : Literal['campaign_target', 'control_group', 'seller_history', 'buyer_portfolio', 'market_benchmark', 'other'] | None

var context : dict[str, typing.Any] | None

var creative_id : str | None

var evidence : adcp.types.versioned_bases._v32._ProvidePerformanceFeedbackRequestBaseEvidence | None

var evidence_ref : str | None

var ext : dict[str, typing.Any] | None

var feedback_source : Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner'] | None

var final : bool | None

var idempotency_key : str

var measurement_period : adcp.types.versioned_bases._v32._ExternalCoreDatetimeRange

var media_buy_id : str

var methodology : str | None

var methodology_version : str | None

var metric : adcp.types.versioned_bases._v32._ProvidePerformanceFeedbackRequestBaseMetricVariant1 | adcp.types.versioned_bases._v32._ProvidePerformanceFeedbackRequestBaseMetricVariant2 | None

var metric_type : Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency'] | None

var model_config

var package_id : str | None

var performance_index : float

var producer : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var study_ref : str | None

var supersedes_feedback_id : str | None

var vendor : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

class ProvidePerformanceFeedbackResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var application_status : Literal['accepted', 'applied', 'not_applied'] | None

var applied_at : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var feedback_id : str | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var received_at : str | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var status_reason : str | None

var success : Literal[True] | None

var task_id : str | None

var timestamp : str | None

class ProviderContextMatchResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_ttl : int | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var governance_context : str | None

var message : str | None

var model_config

var offers : list[adcp.types.versioned_bases._v32._ExternalTrustedMatchOffer]

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signals : adcp.types.versioned_bases._v32._ProviderContextMatchResponseBaseSignals | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var type : Literal['context_match_response']

class ProviderIdentityMatchResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var eligible_package_ids : list[str]

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var request_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var serve_window_sec : int

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var tmpx_chunks : list[adcp.types.versioned_bases._v32._ExternalTrustedMatchTmpxChunk] | None

var type : Literal['identity_match_response']

class RefineProposalsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class RefineProposalsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var governance_context : str | None

var idempotency_key : str

var model_config

var push_notification_config : adcp.types.versioned_bases._v32._RefineProposalsRequestBasePushNotificationConfig | None

var refinements : list[adcp.types.versioned_bases._v32._RefineProposalsRequestBaseRefinementsItemVariant1 | adcp.types.versioned_bases._v32._RefineProposalsRequestBaseRefinementsItemVariant2]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class RefineProposalsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var products : list[adcp.types.versioned_bases._v32._ExternalCoreCanonicalProduct] | None

var replayed : Literal[True] | None

var results : list[adcp.types.versioned_bases._v32._RefineProposalsResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v32._RefineProposalsResponseBaseResultsItemVariant2 | adcp.types.versioned_bases._v32._RefineProposalsResponseBaseResultsItemVariant3 | adcp.types.versioned_bases._v32._RefineProposalsResponseBaseResultsItemVariant4] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed', 'submitted'] | None

var task_id : str | None

class RefineProposalsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class RefineProposalsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class ReportPlanAdjustmentRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var action : Literal['report', 'review']

var adcp_major_version : int | None

var adcp_version : str | None

var adjustment_id : str | None

var adjustment_type : Literal['decommitment', 'refund', 'credit', 'makegood'] | None

var amount : adcp.types.versioned_bases._v32._ReportPlanAdjustmentRequestBaseAmount | None

var context : dict[str, typing.Any] | None

var decision : Literal['accept', 'dispute'] | None

var effective_at : str | None

var evidence : adcp.types.versioned_bases._v32._ReportPlanAdjustmentRequestBaseEvidence | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var outcome_id : str | None

var plan_id : str

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var seller_adjustment_id : str | None

var seller_reference : str | None

class ReportPlanAdjustmentResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var adjustment_id : str

var adjustment_state : Literal['reported', 'verified', 'disputed']

var adjustment_type : Literal['decommitment', 'refund', 'credit', 'makegood']

var amount : adcp.types.versioned_bases._v32._ReportPlanAdjustmentResponseBaseAmount

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var headroom_restored : float

var model_config

var plan_summary : adcp.types.versioned_bases._v32._ReportPlanAdjustmentResponseBasePlanSummary

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ReportPlanOutcomeRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var check_id : str | None

var context : dict[str, typing.Any] | None

var delivery : adcp.types.versioned_bases._v32._ReportPlanOutcomeRequestBaseDelivery | None

var error : adcp.types.versioned_bases._v32._ReportPlanOutcomeRequestBaseError | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var model_config

var outcome : Literal['completed', 'failed', 'delivery']

var plan_id : str

var purchase_type : Literal['media_buy', 'rights_license', 'signal_activation', 'creative_services']

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var seller_response : adcp.types.versioned_bases._v32._ReportPlanOutcomeRequestBaseSellerResponse | None

class ReportPlanOutcomeResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var committed_budget : float | None

var context : dict[str, typing.Any] | None

var delivery_period_state : Literal['open', 'closed'] | None

var delivery_reconciliation_status : Literal['consistent', 'measurement_variance', 'disputed', 'unmatched', 'closed_unresolved'] | None

var ext : dict[str, typing.Any] | None

var findings : list[adcp.types.versioned_bases._v32._ReportPlanOutcomeResponseBaseFindingsItem] | None

var model_config

var outcome_id : str

var outcome_state : Literal['accepted', 'findings']

var plan_summary : adcp.types.versioned_bases._v32._ReportPlanOutcomeResponseBasePlanSummary | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ReportUsageRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var reporting_period : adcp.types.versioned_bases._v32._ExternalCoreDatetimeRange

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var usage : list[adcp.types.versioned_bases._v32._ReportUsageRequestBaseUsageItem]

class ReportUsageResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accepted : int

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class RequestProposalsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var reason : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class RequestProposalsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : dict[str, typing.Any] | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandKey | None

var brief : str

var context : dict[str, typing.Any] | None

var context_id : str | None

var criteria : adcp.types.versioned_bases._v32._ExternalMediaBuyProductDiscoveryCriteria | None

var governance_context : str | None

var idempotency_key : str

var model_config

var opportunity : adcp.types.versioned_bases._v32._RequestProposalsRequestBaseOpportunity | None

var push_notification_config : adcp.types.versioned_bases._v32._RequestProposalsRequestBasePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class RequestProposalsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var incomplete : list[adcp.types.versioned_bases._v32._RequestProposalsResponseBaseIncompleteItem] | None

var message : str | None

var model_config

var outcome : Literal['proposed', 'products_available', 'rejected'] | None

var products : list[adcp.types.versioned_bases._v32._ExternalCoreCanonicalProduct] | None

var proposals : list[adcp.types.versioned_bases._v32._RequestProposalsResponseBaseProposalsItem] | None

var purchase_continuation : adcp.types.versioned_bases._v32._RequestProposalsResponseBasePurchaseContinuationVariant1 | adcp.types.versioned_bases._v32._RequestProposalsResponseBasePurchaseContinuationVariant2 | None

var reason : str | None

var replayed : Literal[True] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed', 'submitted'] | None

var suggestions : list[str] | None

var targeting_resolution : adcp.types.versioned_bases._v32._ExternalMediaBuyGetProductsTargetingResolution | None

var task_id : str | None

class RequestProposalsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class RequestProposalsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class SearchBrandsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var buyer_brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var countries : list[str] | None

var ext : dict[str, typing.Any] | None

var industries : list[typing.Literal['automotive', 'automotive.electric_vehicles', 'automotive.parts_accessories', 'automotive.luxury', 'beauty_cosmetics', 'beauty_cosmetics.skincare', 'beauty_cosmetics.fragrance', 'beauty_cosmetics.haircare', 'cannabis', 'cpg', 'cpg.personal_care', 'cpg.household', 'dating', 'education', 'education.higher_education', 'education.online_learning', 'education.k12', 'energy_utilities', 'energy_utilities.renewable', 'fashion_apparel', 'fashion_apparel.luxury', 'fashion_apparel.sportswear', 'finance', 'finance.banking', 'finance.insurance', 'finance.investment', 'finance.cryptocurrency', 'food_beverage', 'food_beverage.alcohol', 'food_beverage.restaurants', 'food_beverage.packaged_goods', 'gambling_betting', 'gambling_betting.sports_betting', 'gambling_betting.casino', 'gaming', 'gaming.mobile', 'gaming.console_pc', 'gaming.esports', 'government_nonprofit', 'government_nonprofit.political', 'government_nonprofit.charity', 'healthcare', 'healthcare.pharmaceutical', 'healthcare.medical_devices', 'healthcare.wellness', 'home_garden', 'home_garden.furniture', 'home_garden.home_improvement', 'media_entertainment', 'media_entertainment.podcasts', 'media_entertainment.music', 'media_entertainment.film_tv', 'media_entertainment.publishing', 'media_entertainment.live_events', 'pets', 'professional_services', 'professional_services.legal', 'professional_services.consulting', 'real_estate', 'real_estate.residential', 'real_estate.commercial', 'recruitment_hr', 'retail', 'retail.ecommerce', 'retail.department_stores', 'sports_fitness', 'sports_fitness.equipment', 'sports_fitness.teams_leagues', 'technology', 'technology.software', 'technology.hardware', 'technology.ai_ml', 'telecom', 'telecom.mobile_carriers', 'telecom.internet_providers', 'transportation_logistics', 'travel_hospitality', 'travel_hospitality.airlines', 'travel_hospitality.hotels', 'travel_hospitality.cruise', 'travel_hospitality.tourism']] | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationRequest | None

var query : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SearchBrandsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var brands : list[adcp.types.versioned_bases._v32._SearchBrandResult] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._ExternalCorePaginationResponse | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SiGetOfferingRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_products : bool

var intent : str | None

var model_config

var offering_id : str

var product_limit : int

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SiGetOfferingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var alternative_offering_ids : list[str] | None

var available : bool

var checked_at : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var matching_products : list[adcp.types.versioned_bases._v32._SiGetOfferingResponseBaseMatchingProductsItem] | None

var message : str | None

var model_config

var offering : adcp.types.versioned_bases._v32._SiGetOfferingResponseBaseOffering | None

var offering_token : str | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sponsored_context : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiSponsoredContext | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var total_matching : int | None

var ttl_seconds : int | None

var unavailable_reason : str | None

class SiInitiateSessionRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var identity : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiIdentity

var intent : str

var media_buy_id : str | None

var model_config

var offering_id : str | None

var offering_token : str | None

var placement : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sponsored_context_receipt : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None

var supported_capabilities : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiCapabilities | None

class SiInitiateSessionResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var negotiated_capabilities : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiCapabilities | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var response : adcp.types.versioned_bases._v32._SiInitiateSessionResponseBaseResponse | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var session_id : str

var session_status : Literal['active', 'pending_handoff', 'complete', 'terminated']

var session_ttl_seconds : int | None

var sponsored_context : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiSponsoredContext | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SiSendMessageRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var action_response : adcp.types.versioned_bases._v32._SiSendMessageRequestBaseActionResponse | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var session_id : str

var sponsored_context_receipt : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None

class SiSendMessageResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var handoff : adcp.types.versioned_bases._v32._SiSendMessageResponseBaseHandoff | None

var mcp_resource_uri : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var response : adcp.types.versioned_bases._v32._SiSendMessageResponseBaseResponse | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var session_id : str

var session_status : Literal['active', 'pending_handoff', 'complete', 'terminated']

var sponsored_context : adcp.types.versioned_bases._v32._ExternalSponsoredIntelligenceSiSponsoredContext | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SiTerminateSessionRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['handoff_transaction', 'handoff_complete', 'user_exit', 'session_timeout', 'host_terminated']

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var session_id : str

var termination_context : adcp.types.versioned_bases._v32._SiTerminateSessionRequestBaseTerminationContext | None

class SiTerminateSessionResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var acp_handoff : adcp.types.versioned_bases._v32._SiTerminateSessionResponseBaseAcpHandoff | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var follow_up : adcp.types.versioned_bases._v32._SiTerminateSessionResponseBaseFollowUp | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var session_id : str

var session_status : Literal['active', 'pending_handoff', 'complete', 'terminated'] | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var terminated : bool

var timestamp : str | None

class StaleResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var cache_age_seconds : int

var freshness_target_seconds : int | None

var model_config

var original_error : adcp.types.versioned_bases._v32._StaleResponseBaseOriginalError | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var served_from_cache : Literal[True]

var upstream : adcp.types.versioned_bases._v32._StaleResponseBaseUpstream | None

class SyncAccountsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.versioned_bases._v32._SyncAccountsRequestBaseAccountsItemVariant1 | adcp.types.versioned_bases._v32._SyncAccountsRequestBaseAccountsItemVariant2]

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var delete_missing : bool

var dry_run : bool

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncAccountsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.versioned_bases._v32._SyncAccountsResponseBaseAccountsItem] | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SyncAgentNotificationConfigsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var dry_run : bool

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var notification_configs : list[adcp.types.versioned_bases._v32._SyncAgentNotificationConfigsRequestBaseNotificationConfigsItem]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncAgentNotificationConfigsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var action : Literal['updated', 'unchanged', 'cleared', 'failed']

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var notification_configs : list[adcp.types.versioned_bases._v32._ExternalCoreAgentNotificationConfig] | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SyncAudiencesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._SyncAudiencesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._SyncAudiencesRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var audiences : list[adcp.types.versioned_bases._v32._SyncAudiencesRequestBaseAudiencesItem] | None

var context : dict[str, typing.Any] | None

var delete_missing : bool

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncAudiencesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var audiences : list[adcp.types.versioned_bases._v32._SyncAudiencesResponseBaseAudiencesItem] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

class SyncCatalogsInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['APPROVAL_REQUIRED', 'FEED_VALIDATION', 'ITEM_REVIEW', 'FEED_ACCESS'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncCatalogsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._SyncCatalogsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._SyncCatalogsRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var catalog_ids : list[str] | None

var catalogs : list[adcp.types.versioned_bases._v32._ExternalCoreCatalog] | None

var context : dict[str, typing.Any] | None

var delete_missing : bool

var dry_run : bool

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var item_availability_queries : list[adcp.types.versioned_bases._v32._ExternalCoreCatalogItemAvailabilityRef] | None

var item_availability_updates : list[adcp.types.versioned_bases._v32._ExternalCoreCatalogItemAvailabilityUpdate] | None

var model_config

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var validation_mode : Literal['strict', 'lenient']

class SyncCatalogsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var catalogs : list[adcp.types.versioned_bases._v32._SyncCatalogsResponseBaseCatalogsItem] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v32._SyncCatalogsResponseBaseErrorsItem] | list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var item_availability_states : list[adcp.types.versioned_bases._v32._ExternalCoreCatalogItemAvailabilityState] | None

var item_availability_updates : list[adcp.types.versioned_bases._v32._ExternalCoreCatalogItemAvailabilityUpdateResult] | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['completed'] | Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

class SyncCatalogsSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class SyncCatalogsWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var catalogs_processed : int | None

var catalogs_total : int | None

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var items_processed : int | None

var items_total : int | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class SyncCreativesInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['APPROVAL_REQUIRED', 'ASSET_CONFIRMATION', 'FORMAT_CLARIFICATION'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncCreativesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var assignment_operations : list[adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAssignmentOperationsItemVariant1 | adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAssignmentOperationsItemVariant2 | adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAssignmentOperationsItemVariant3] | None

var assignments : list[adcp.types.versioned_bases._v32._SyncCreativesRequestBaseAssignmentsItem] | None

var context : dict[str, typing.Any] | None

var creative_ids : list[str] | None

var creatives : list[adcp.types.versioned_bases._v32._SyncCreativesRequestBaseCreativesItemVariant1 | adcp.types.versioned_bases._v32._SyncCreativesRequestBaseCreativesItemVariant2] | None

var delete_missing : bool

var dry_run : bool

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var validation_mode : Literal['strict', 'lenient']

class SyncCreativesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var creatives : list[adcp.types.versioned_bases._v32._SyncCreativesResponseBaseCreativesItem] | None

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

class SyncCreativesSubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class SyncCreativesWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var creatives_processed : int | None

var creatives_total : int | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class SyncEventSourcesRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._SyncEventSourcesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._SyncEventSourcesRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var delete_missing : bool

var event_sources : list[adcp.types.versioned_bases._v32._SyncEventSourcesRequestBaseEventSourcesItem] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncEventSourcesResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var event_sources : list[adcp.types.versioned_bases._v32._SyncEventSourcesResponseBaseEventSourcesItem] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SyncGovernanceRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.versioned_bases._v32._SyncGovernanceRequestBaseAccountsItem]

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncGovernanceResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.versioned_bases._v32._SyncGovernanceResponseBaseAccountsItem] | None

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class SyncPlansRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var plans : list[adcp.types.versioned_bases._v32._SyncPlansRequestBasePlansItem]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class SyncPlansResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var plans : list[adcp.types.versioned_bases._v32._SyncPlansResponseBasePlansItem]

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class TasksGetRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._TasksGetRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._TasksGetRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_history : bool

var include_result : bool

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var task_id : str

class TasksGetResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._TasksGetResponseBaseAdcpError | None

var adcp_major_version : int | None

var adcp_version : str | None

var completed_at : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var created_at : str

var error : adcp.types.versioned_bases._v32._TasksGetResponseBaseError | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var has_webhook : bool | None

var history : list[adcp.types.versioned_bases._v32._TasksGetResponseBaseHistoryItem] | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var progress : adcp.types.versioned_bases._v32._TasksGetResponseBaseProgress | None

var protocol : Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']

var push_notification_config : adcp.types.versioned_bases._v32._TasksGetResponseBasePushNotificationConfig | None

var replayed : bool

var result : dict[str, typing.Any] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str

var task_type : Literal['create_media_buy', 'update_media_buy', 'buy_products', 'accept_proposal', 'control_media_buy', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'preview_creative', 'activate_signal', 'get_products', 'request_proposals', 'refine_proposals', 'decline_proposals', 'get_signals', 'create_property_list', 'update_property_list', 'get_property_list', 'list_property_lists', 'delete_property_list', 'sync_accounts', 'get_account_financials', 'get_creative_delivery', 'sync_event_sources', 'sync_audiences', 'sync_catalogs', 'log_event', 'get_brand_identity', 'search_brands', 'get_rights', 'acquire_rights', 'update_rights', 'sync_agent_notification_configs']

var timestamp : str | None

var updated_at : str

class TasksListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._TasksListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._TasksListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._TasksListRequestBaseFilters | None

var include_history : bool

var model_config

var pagination : adcp.types.versioned_bases._v32._TasksListRequestBasePagination | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var sort : adcp.types.versioned_bases._v32._TasksListRequestBaseSort | None

class TasksListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._TasksListResponseBaseAdcpError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.versioned_bases._v32._TasksListResponseBasePagination

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._TasksListResponseBasePushNotificationConfig | None

var query_summary : adcp.types.versioned_bases._v32._TasksListResponseBaseQuerySummary

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var tasks : list[adcp.types.versioned_bases._v32._TasksListResponseBaseTasksItem]

var timestamp : str | None

class UpdateCollectionListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._UpdateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._UpdateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_collections : list[adcp.types.versioned_bases._v32._UpdateCollectionListRequestBaseBaseCollectionsItemVariant1 | adcp.types.versioned_bases._v32._UpdateCollectionListRequestBaseBaseCollectionsItemVariant2 | adcp.types.versioned_bases._v32._UpdateCollectionListRequestBaseBaseCollectionsItemVariant3] | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var description : str | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._ExternalCollectionCollectionListFilters | None

var idempotency_key : str

var list_id : str

var model_config

var name : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var webhook_url : str | None

class UpdateCollectionListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list : adcp.types.versioned_bases._v32._ExternalCollectionCollectionList

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class UpdateContentStandardsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var calibration_exemplars : adcp.types.versioned_bases._v32._UpdateContentStandardsRequestBaseCalibrationExemplars | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var idempotency_key : str

var model_config

var policies : list[adcp.types.versioned_bases._v32._ExternalGovernancePolicyEntry] | None

var registry_policy_ids : list[str] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var scope : adcp.types.versioned_bases._v32._UpdateContentStandardsRequestBaseScope | None

var standards_id : str

class UpdateContentStandardsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var conflicting_standards_id : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var success : Literal[True] | Literal[False]

var task_id : str | None

var timestamp : str | None

class UpdateMediaBuyInputRequiredResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var model_config

var reason : Literal['APPROVAL_REQUIRED', 'CHANGE_CONFIRMATION'] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class UpdateMediaBuyRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._UpdateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._UpdateMediaBuyRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var bidding : adcp.types.versioned_bases._v32._ExternalCoreBiddingPolicy | None

var budget_allocation : adcp.types.versioned_bases._v32._UpdateMediaBuyRequestBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._UpdateMediaBuyRequestBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var canceled : Literal[True] | None

var cancellation_reason : str | None

var context : dict[str, typing.Any] | None

var daily_budget_cap : float | None

var end_time : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var media_buy_id : str

var model_config

var name : str | None

var new_packages : list[adcp.types.versioned_bases._v32._ExternalMediaBuyPackageRequest] | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var packages : list[adcp.types.versioned_bases._v32._ExternalMediaBuyPackageUpdate] | None

var paused : bool | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v32._ExternalCoreReportingWebhook | None

var revision : int | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var start_time : Literal['asap'] | str | None

var total_budget : adcp.types.versioned_bases._v32._UpdateMediaBuyRequestBaseTotalBudget | None

class UpdateMediaBuyResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var affected_packages : list[adcp.types.versioned_bases._v32._ExternalCorePackage] | None

var available_actions : list[adcp.types.versioned_bases._v32._ExternalCoreMediaBuyAvailableAction] | None

var bidding : adcp.types.versioned_bases._v32._UpdateMediaBuyResponseBaseBidding | None

var budget_allocation : adcp.types.versioned_bases._v32._UpdateMediaBuyResponseBaseBudgetAllocationVariant1 | adcp.types.versioned_bases._v32._UpdateMediaBuyResponseBaseBudgetAllocationVariant2 | None

var budget_cap_timezone : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var currency : str | None

var daily_budget_cap : float | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var implementation_date : str | None

var invoice_recipient : adcp.types.versioned_bases._v32._ExternalCoreBusinessEntity | None

var media_buy_id : str | None

var media_buy_status : Literal['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var message : str | None

var model_config

var name : str | None

var pacing : Literal['even', 'asap', 'front_loaded'] | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var revision : int | None

var sandbox : bool | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown'] | Literal['submitted']

var task_id : str | None

var timestamp : str | None

var total_budget : float | None

var valid_actions : list[typing.Literal['pause', 'resume', 'cancel', 'update_name', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_budget_allocation', 'update_targeting', 'update_pacing', 'update_bidding', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | None

var warnings : list[adcp.types.versioned_bases._v32._ExternalCoreWarning] | None

class UpdateMediaBuySubmittedResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var message : str | None

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted']

var task_id : str

class UpdateMediaBuyWorkingResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var context : dict[str, typing.Any] | None

var current_step : str | None

var ext : dict[str, typing.Any] | None

var model_config

var percentage : float | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var step_number : int | None

var total_steps : int | None

class UpdatePropertyListRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._UpdatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._UpdatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_properties : list[adcp.types.versioned_bases._v32._UpdatePropertyListRequestBaseBasePropertiesItemVariant1 | adcp.types.versioned_bases._v32._UpdatePropertyListRequestBaseBasePropertiesItemVariant2 | adcp.types.versioned_bases._v32._UpdatePropertyListRequestBaseBasePropertiesItemVariant3] | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var context : dict[str, typing.Any] | None

var description : str | None

var ext : dict[str, typing.Any] | None

var filters : adcp.types.versioned_bases._v32._ExternalPropertyPropertyListFilters | None

var idempotency_key : str

var list_id : str

var model_config

var name : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var webhook_url : str | None

class UpdatePropertyListResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list : adcp.types.versioned_bases._v32._ExternalPropertyPropertyList

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class UpdateRightsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._UpdateRightsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._UpdateRightsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var end_date : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var idempotency_key : str

var impression_cap : int | None

var model_config

var paused : bool | None

var pricing_option_id : str | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var rights_id : str

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class UpdateRightsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var generation_credentials : list[adcp.types.versioned_bases._v32._ExternalCoreGenerationCredential] | None

var governance_context : str | None

var implementation_date : str | None

var message : str | None

var model_config

var paused : bool | None

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights_constraint : adcp.types.versioned_bases._v32._UpdateRightsResponseBaseRightsConstraint | None

var rights_id : str | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var terms : adcp.types.versioned_bases._v32._ExternalBrandRightsTerms | None

var timestamp : str | None

class ValidateContentDeliveryRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var feature_ids : list[str] | None

var include_passed : bool

var model_config

var records : list[adcp.types.versioned_bases._v32._ValidateContentDeliveryRequestBaseRecordsItem]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var standards_id : str

class ValidateContentDeliveryResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v32._ValidateContentDeliveryResponseBaseResultsItem] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var summary : adcp.types.versioned_bases._v32._ValidateContentDeliveryResponseBaseSummary | None

var task_id : str | None

var timestamp : str | None

class ValidateInputRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ValidateInputRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ValidateInputRequestBaseAccountVariant2 | None

var brand : adcp.types.versioned_bases._v32._ExternalCoreBrandRef | None

var manifest : adcp.types.versioned_bases._v32._ValidateInputRequestBaseManifestVariant1 | adcp.types.versioned_bases._v32._ValidateInputRequestBaseManifestVariant2

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var targets : list[adcp.types.versioned_bases._v32._ValidateInputRequestBaseTargetsItemVariant1 | adcp.types.versioned_bases._v32._ValidateInputRequestBaseTargetsItemVariant2 | adcp.types.versioned_bases._v32._ValidateInputRequestBaseTargetsItemVariant3 | adcp.types.versioned_bases._v32._ValidateInputRequestBaseTargetsItemVariant4] | None

class ValidateInputResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v32._ExternalCreativeValidateInputResult]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

class ValidatePropertyDeliveryRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.versioned_bases._v32._ValidatePropertyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v32._ValidatePropertyDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var ext : dict[str, typing.Any] | None

var include_compliant : bool

var list_id : str

var model_config

var records : list[adcp.types.versioned_bases._v32._ExternalPropertyDeliveryRecord]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class ValidatePropertyDeliveryResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var aggregate : adcp.types.versioned_bases._v32._ValidatePropertyDeliveryResponseBaseAggregate | None

var authorization_summary : adcp.types.versioned_bases._v32._ValidatePropertyDeliveryResponseBaseAuthorizationSummary | None

var compliant : bool | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var list_id : str

var list_resolved_at : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v32._ExternalPropertyValidationResult]

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var summary : adcp.types.versioned_bases._v32._ValidatePropertyDeliveryResponseBaseSummary

var task_id : str | None

var timestamp : str | None

var validated_at : str

class VerifyBrandClaimRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var claim : adcp.types.versioned_bases._v32._VerifyBrandClaimRequestBaseClaim | adcp.types.versioned_bases._v32._VerifyBrandClaimRequestBaseClaim2 | adcp.types.versioned_bases._v32._VerifyBrandClaimRequestBaseClaim3 | adcp.types.versioned_bases._v32._VerifyBrandClaimRequestBaseClaim4

var claim_type : Literal['subsidiary'] | Literal['parent'] | Literal['property'] | Literal['trademark']

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class VerifyBrandClaimResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var claim_type : Literal['subsidiary', 'parent', 'property', 'trademark'] | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var context_note : str | None

var details : dict[str, typing.Any] | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signed_response : adcp.types.versioned_bases._v32._SignedResponse | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None

var verification_status : Literal['owned', 'pending_review', 'transferring', 'disputed', 'not_ours', 'archived', 'licensed_in', 'licensed_out', 'unknown'] | None

class VerifyBrandClaimsRequestBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var claims : list[adcp.types.versioned_bases._v32._VerifyBrandClaimsRequestBaseClaimsItemVariant1 | adcp.types.versioned_bases._v32._VerifyBrandClaimsRequestBaseClaimsItemVariant2 | adcp.types.versioned_bases._v32._VerifyBrandClaimsRequestBaseClaimsItemVariant3 | adcp.types.versioned_bases._v32._VerifyBrandClaimsRequestBaseClaimsItemVariant4]

var model_config

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

class VerifyBrandClaimsResponseBase (**data: Any)

Normal Pydantic base carrying one pinned protocol boundary shape.

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

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

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

Ancestors

• adcp.types.versioned._VersionedExtensionModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.versioned_bases._v32._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : dict[str, typing.Any] | None

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v32._ExternalCoreError] | None

var ext : dict[str, typing.Any] | None

var governance_context : str | None

var message : str | None

var model_config

var payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v32._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v32._VerifyBrandClaimsResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v32._VerifyBrandClaimsResponseBaseResultsItemVariant2] | None

var schema_direction : ClassVar[Literal['request', 'sync', 'submitted', 'working', 'input-required']]

var schema_document : ClassVar[dict[str, Any]]

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var signed_response : adcp.types.versioned_bases._v32._SignedResponse2 | None

var status : Literal['submitted', 'working', 'input-required', 'completed', 'canceled', 'failed', 'rejected', 'auth-required', 'unknown']

var task_id : str | None

var timestamp : str | None