Module adcp.types.versioned_bases.v31

Generated lazy named extension bases for the pinned bundled schema.

Classes

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._v31._AcquireRightsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._AcquireRightsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

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

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

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

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

var idempotency_key : str

var model_config

var pricing_option_id : str

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

var revocation_webhook : adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var approval_webhook : adcp.types.versioned_bases._v31._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._v31._AcquireRightsResponseBaseDisclosure | None

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

var estimated_response_time : str | None

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

var generation_credentials : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var reason : str | None

var replayed : bool

var restrictions : list[str] | None

var rights_constraint : adcp.types.versioned_bases._v31._ExternalCoreRightsConstraint | 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._v31._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._v31._ActivateSignalRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._ActivateSignalRequestBaseDestinationsItemVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._ActivateSignalResponseBaseDeploymentsItemVariant1 | adcp.types.versioned_bases._v31._ActivateSignalResponseBaseDeploymentsItemVariant2] | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._BuildCreativeRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._BuildCreativeRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var brand : adcp.types.versioned_bases._v31._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._v31._BuildCreativeRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v31._BuildCreativeRequestBaseCreativeManifestVariant2 | None

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

var ext : dict[str, typing.Any] | 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._v31._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._v31._BuildCreativeRequestBasePreviewInputsItem] | None

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._BuildCreativeRequestBaseSignalConditionsItemVariant1 | adcp.types.versioned_bases._v31._BuildCreativeRequestBaseSignalConditionsItemVariant2 | adcp.types.versioned_bases._v31._BuildCreativeRequestBaseSignalConditionsItemVariant3] | None

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

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

var transformer_id : str | None

var variant_axis : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreCreativeConsumption | None

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

var context_id : str | None

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

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

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

var currency : str | None

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

var estimate : adcp.types.versioned_bases._v31._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._v31._BuildCreativeResponseBasePreview | adcp.types.versioned_bases._v31._BuildCreativeResponseBasePreview2 | None

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

var pricing_option_id : str | None

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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 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._v31._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._v31._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._v31._ExternalCoreError] | None

var explanation : str | None

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

var features : list[adcp.types.versioned_bases._v31._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._v31._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 context : dict[str, typing.Any] | None

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

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

var governance_context : str | None

var invoice_recipient : adcp.types.versioned_bases._v31._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

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

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 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 conditions : list[adcp.types.versioned_bases._v31._CheckGovernanceResponseBaseConditionsItem] | None

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

var expires_at : str | None

var explanation : str

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

var findings : list[adcp.types.versioned_bases._v31._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

var policies_evaluated : 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 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._v31._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._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var audit_observations : list[adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCorePushNotificationConfig | None

var recorded_calls : list[adcp.types.versioned_bases._v31._ComplyTestControllerResponseBaseRecordedCallsItemVariant1 | adcp.types.versioned_bases._v31._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._v31._ExternalContentStandardsArtifact | None

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

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

var geo : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalTrustedMatchOffer]

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ContextMatchResponseBaseSignals | 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 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._v31._CreateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._CreateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

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

var brand : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCollectionCollectionList

var message : str | None

var model_config

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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._v31._CreateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._CreateMediaBuyRequestBaseArtifactWebhook | None

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

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

var end_time : str

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

var idempotency_key : str

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

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

var model_config

var packages : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var reporting_webhook : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreAccount | None

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

var adcp_major_version : int | None

var adcp_version : str | None

var available_actions : list[adcp.types.versioned_bases._v31._ExternalCoreMediaBuyAvailableAction] | 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 errors : list[adcp.types.versioned_bases._v31._ExternalCoreError] | None

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

var governance_context : str | None

var invoice_recipient : adcp.types.versioned_bases._v31._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 packages : list[adcp.types.versioned_bases._v31._ExternalCorePackage] | None

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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['completed', 'canceled', 'rejected'] | 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', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | 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._v31._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._v31._CreatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._CreatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

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

var brand : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalPropertyPropertyList

var message : str | None

var model_config

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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 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._v31._DeleteCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._DeletePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetAccountFinancialsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._GetAccountFinancialsResponseBaseAccountVariant1 | adcp.types.versioned_bases._v31._GetAccountFinancialsResponseBaseAccountVariant2 | None

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

var adcp_major_version : int | None

var adcp_version : str | None

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

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

var context_id : str | None

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

var currency : str | None

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

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

var governance_context : str | None

var invoices : list[adcp.types.versioned_bases._v31._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._v31._ExternalCoreDateRange | None

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._GetAdcpCapabilitiesResponseBaseAccount | None

var adcp : adcp.types.versioned_bases._v31._GetAdcpCapabilitiesResponseBaseAdcp

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

var adcp_major_version : int | None

var adcp_version : str | None

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

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

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

var context_id : str | None

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

var errors : list[adcp.types.versioned_bases._v31._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._v31._GetAdcpCapabilitiesResponseBaseGovernance | None

var governance_context : str | None

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

var last_updated : str | None

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

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

var message : str | None

var model_config

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

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

var replayed : bool

var request_signing : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetAdcpCapabilitiesResponseBaseWebhookSigning | None

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

var wholesale_feed_webhooks : adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var assets : list[adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError] | None

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

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

var governance_context : str | None

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

var industries : list[str] | None

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

var logos : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights : adcp.types.versioned_bases._v31._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._v31._GetBrandIdentityResponseBaseTone | None

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

var voice_synthesis : adcp.types.versioned_bases._v31._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._v31._GetCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetCollectionListResponseBaseCollectionsItem] | None

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

var context_id : str | None

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

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

var governance_context : str | None

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

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var calibration_exemplars : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalGovernancePolicyEntry] | None

var pricing_options : list[adcp.types.versioned_bases._v31._GetContentStandardsResponseBasePricingOptionsItemVariant1 | adcp.types.versioned_bases._v31._GetContentStandardsResponseBasePricingOptionsItemVariant2 | adcp.types.versioned_bases._v31._GetContentStandardsResponseBasePricingOptionsItemVariant3 | adcp.types.versioned_bases._v31._GetContentStandardsResponseBasePricingOptionsItemVariant4 | adcp.types.versioned_bases._v31._GetContentStandardsResponseBasePricingOptionsItemVariant5] | None

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._GetCreativeDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetCreativeDeliveryResponseBaseCreativesItem]

var currency : str

var errors : list[adcp.types.versioned_bases._v31._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._v31._GetCreativeDeliveryResponseBasePagination | None

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

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

var replayed : bool

var reporting_period : adcp.types.versioned_bases._v31._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._v31._GetCreativeFeaturesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._GetCreativeFeaturesRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

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

var consumption : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v31._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._v31._GetMediaBuyArtifactsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var artifacts : list[adcp.types.versioned_bases._v31._GetMediaBuyArtifactsResponseBaseArtifactsItem] | None

var collection_info : adcp.types.versioned_bases._v31._GetMediaBuyArtifactsResponseBaseCollectionInfo | None

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

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePaginationResponse | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._GetMediaBuyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._GetMediaBuyDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var attribution_window : adcp.types.versioned_bases._v31._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._v31._GetMediaBuyDeliveryRequestBaseReportingDimensions | 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', 'monthly'] | 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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var aggregated_totals : adcp.types.versioned_bases._v31._GetMediaBuyDeliveryResponseBaseAggregatedTotals | None

var attribution_window : adcp.types.versioned_bases._v31._ExternalCoreAttributionWindow | None

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

var context_id : str | None

var currency : str

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

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

var governance_context : str | None

var media_buy_deliveries : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var reporting_period : adcp.types.versioned_bases._v31._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._v31._GetMediaBuysRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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 media_buy_ids : list[str] | None

var model_config

var pagination : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError] | None

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

var governance_context : str | None

var media_buys : list[adcp.types.versioned_bases._v31._GetMediaBuysResponseBaseMediaBuysItem]

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._GetPlanAuditLogsResponseBasePlansItem]

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._GetProductsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._GetProductsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

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

var brief : str | None

var buying_mode : Literal['brief', 'wholesale', 'refine']

var catalog : adcp.types.versioned_bases._v31._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', 'max_optimization_goals', 'catalog_match', 'collections', 'collection_targeting_allowed', 'installments', 'brief_relevance', 'expires_at', 'product_card', 'product_card_detailed', 'enforced_policies', 'trusted_match']] | None

var filters : adcp.types.versioned_bases._v31._ExternalCoreProductFilters | None

var if_pricing_version : str | None

var if_wholesale_feed_version : str | None

var model_config

var pagination : adcp.types.versioned_bases._v31._ExternalCorePaginationRequest | None

var preferred_delivery_types : list[typing.Literal['guaranteed', 'non_guaranteed']] | None

var property_list : adcp.types.versioned_bases._v31._ExternalCorePropertyListRef | None

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

var refine : list[adcp.types.versioned_bases._v31._GetProductsRequestBaseRefineItemVariant1 | adcp.types.versioned_bases._v31._GetProductsRequestBaseRefineItemVariant2 | adcp.types.versioned_bases._v31._GetProductsRequestBaseRefineItemVariant3] | 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 time_budget : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError] | None

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

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

var filter_diagnostics : adcp.types.versioned_bases._v31._GetProductsResponseBaseFilterDiagnostics | None

var governance_context : str | None

var incomplete : list[adcp.types.versioned_bases._v31._GetProductsResponseBaseIncompleteItem] | None

var message : str | None

var model_config

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

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

var pricing_version : str | None

var products : list[adcp.types.versioned_bases._v31._ExternalCoreProduct] | None

var property_list_applied : bool | None

var proposals : list[adcp.types.versioned_bases._v31._ExternalCoreProposal] | None

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

var refinement_applied : list[adcp.types.versioned_bases._v31._GetProductsResponseBaseRefinementAppliedItemVariant1 | adcp.types.versioned_bases._v31._GetProductsResponseBaseRefinementAppliedItemVariant2 | adcp.types.versioned_bases._v31._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 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._v31._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._v31._GetPropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCoreIdentifier]] | None

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

var governance_context : str | None

var identifiers : list[adcp.types.versioned_bases._v31._ExternalCoreIdentifier] | None

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

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._ExternalCoreError] | None

var excluded : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights : list[adcp.types.versioned_bases._v31._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._v31._GetSignalsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._GetSignalsRequestBaseDestinationsItemVariant1 | adcp.types.versioned_bases._v31._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', '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._v31._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._v31._ExternalCorePaginationRequest | None

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._GetSignalsRequestBaseSignalIdsItemVariant1 | adcp.types.versioned_bases._v31._GetSignalsRequestBaseSignalIdsItemVariant2] | None

var signal_refs : list[adcp.types.versioned_bases._v31._GetSignalsRequestBaseSignalRefsItemVariant1 | adcp.types.versioned_bases._v31._GetSignalsRequestBaseSignalRefsItemVariant2 | adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError] | None

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

var governance_context : str | None

var incomplete : list[adcp.types.versioned_bases._v31._GetSignalsResponseBaseIncompleteItem] | None

var message : str | None

var model_config

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

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

var pricing_version : str | None

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetTaskStatusRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._GetTaskStatusResponseBaseHistoryItem] | None

var message : str | None

var model_config

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

var progress : adcp.types.versioned_bases._v31._GetTaskStatusResponseBaseProgress | None

var protocol : Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']

var push_notification_config : adcp.types.versioned_bases._v31._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', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', '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']

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._v31._IdentityMatchRequestBaseConsent | None

var country : str | None

var identities : list[adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._ListAccountsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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 model_config

var pagination : adcp.types.versioned_bases._v31._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

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._v31._ExternalCoreAccountWithAuthorization]

var adcp_error : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCorePaginationResponse | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ListCollectionListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCollectionCollectionList]

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._ExternalCorePaginationResponse | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._ListCreativeFormatsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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', '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._v31._ExternalCoreFormatId] | None

var include_pricing : bool

var input_format_ids : list[adcp.types.versioned_bases._v31._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._v31._ExternalCoreFormatId] | None

var pagination : adcp.types.versioned_bases._v31._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._v31._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._v31._ListCreativeFormatsResponseBaseCreativeAgentsItem] | None

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

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

var formats : list[adcp.types.versioned_bases._v31._ExternalCoreFormat]

var governance_context : str | None

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ListCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._ListCreativesRequestBaseAccountVariant2 | 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 fields : list[typing.Literal['creative_id', 'name', 'format_id', 'status', 'created_date', 'updated_date', 'tags', 'assignments', 'snapshot', 'items', 'variables', 'concept', 'pricing_options']] | None

var filters : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._ListCreativesResponseBaseCreativesItemVariant1 | adcp.types.versioned_bases._v31._ListCreativesResponseBaseCreativesItemVariant2]

var errors : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePaginationResponse

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

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

var query_summary : adcp.types.versioned_bases._v31._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._v31._ListCreativesResponseBaseStatusSummary | None

var task_id : str | None

var timestamp : str | None

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._v31._ListPropertyListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalPropertyPropertyList]

var message : str | None

var model_config

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

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ListTasksRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._ListTasksRequestBaseFilters | None

var include_history : bool

var model_config

var pagination : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCorePaginationResponse

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

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

var query_summary : adcp.types.versioned_bases._v31._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._v31._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._v31._ListTransformersRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreFormatId] | None

var model_config

var name_search : str | None

var output_format_ids : list[adcp.types.versioned_bases._v31._ExternalCoreFormatId] | None

var pagination : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCorePaginationResponse | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._LogEventResponseBasePartialFailuresItem] | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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 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 bid_price : float | None

var budget : float

var catalogs : list[adcp.types.versioned_bases._v31._ExternalCoreCatalog] | None

var committed_metrics : list[adcp.types.versioned_bases._v31._PackageRequestBaseCommittedMetricsItemVariant1 | adcp.types.versioned_bases._v31._PackageRequestBaseCommittedMetricsItemVariant2] | None

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

var creative_assignments : list[adcp.types.versioned_bases._v31._ExternalCoreCreativeAssignment] | None

var creatives : list[adcp.types.versioned_bases._v31._PackageRequestBaseCreativesItemVariant1 | adcp.types.versioned_bases._v31._PackageRequestBaseCreativesItemVariant2] | None

var end_time : str | None

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

var format_ids : list[adcp.types.versioned_bases._v31._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', 'custom'] | None

var format_option_refs : list[adcp.types.versioned_bases._v31._PackageRequestBaseFormatOptionRefsItemVariant1 | adcp.types.versioned_bases._v31._PackageRequestBaseFormatOptionRefsItemVariant2] | None

var impressions : float | None

var measurement_terms : adcp.types.versioned_bases._v31._ExternalCoreMeasurementTerms | None

var model_config

var optimization_goals : list[adcp.types.versioned_bases._v31._PackageRequestBaseOptimizationGoalsItemVariant1 | adcp.types.versioned_bases._v31._PackageRequestBaseOptimizationGoalsItemVariant2 | adcp.types.versioned_bases._v31._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._v31._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._v31._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 context : dict[str, typing.Any] | None

var creative_id : str | None

var creative_manifest : adcp.types.versioned_bases._v31._PreviewCreativeRequestBaseCreativeManifestVariant1 | adcp.types.versioned_bases._v31._PreviewCreativeRequestBaseCreativeManifestVariant2 | None

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

var format_id : adcp.types.versioned_bases._v31._ExternalCoreFormatId | None

var inputs : list[adcp.types.versioned_bases._v31._PreviewCreativeRequestBaseInputsItem] | None

var item_limit : int | None

var model_config

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

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

var request_type : Literal['single', 'batch', 'variant']

var requests : list[adcp.types.versioned_bases._v31._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 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._v31._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._v31._PreviewCreativeResponseBaseManifestVariant1 | adcp.types.versioned_bases._v31._PreviewCreativeResponseBaseManifestVariant2 | None

var message : str | None

var model_config

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

var previews : list[adcp.types.versioned_bases._v31._PreviewCreativeResponseBasePreviewsItem] | list[adcp.types.versioned_bases._v31._PreviewCreativeResponseBasePreviewsItem2] | None

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

var replayed : bool

var response_type : Literal['single'] | Literal['batch'] | Literal['variant']

var results : list[adcp.types.versioned_bases._v31._PreviewCreativeResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v31._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']

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 context : dict[str, typing.Any] | None

var creative_id : str | None

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

var feedback_source : Literal['buyer_attribution', 'third_party_measurement', 'platform_analytics', 'verification_partner']

var idempotency_key : str

var measurement_period : adcp.types.versioned_bases._v31._ExternalCoreDatetimeRange

var media_buy_id : str

var metric_type : Literal['overall_performance', 'conversion_rate', 'brand_lift', 'click_through_rate', 'completion_rate', 'viewability', 'brand_safety', 'cost_efficiency']

var model_config

var package_id : str | None

var performance_index : float

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 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._v31._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._v31._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._v31._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 success : Literal[True] | None

var task_id : str | None

var timestamp : str | None

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._v31._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._v31._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._v31._ExternalTrustedMatchTmpxChunk] | None

var type : Literal['identity_match_response']

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._v31._ReportPlanOutcomeRequestBaseDelivery | None

var error : adcp.types.versioned_bases._v31._ReportPlanOutcomeRequestBaseError | None

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

var governance_context : str

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._v31._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 ext : dict[str, typing.Any] | None

var findings : list[adcp.types.versioned_bases._v31._ReportPlanOutcomeResponseBaseFindingsItem] | None

var model_config

var outcome_id : str

var outcome_state : Literal['accepted', 'findings']

var plan_summary : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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 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._v31._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._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var brands : list[adcp.types.versioned_bases._v31._SearchBrandResult] | None

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

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePaginationResponse | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError] | None

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

var governance_context : str | None

var matching_products : list[adcp.types.versioned_bases._v31._SiGetOfferingResponseBaseMatchingProductsItem] | None

var message : str | None

var model_config

var offering : adcp.types.versioned_bases._v31._SiGetOfferingResponseBaseOffering | None

var offering_token : str | None

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalSponsoredIntelligenceSiSponsoredContextReceipt | None

var supported_capabilities : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalSponsoredIntelligenceSiCapabilities | None

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

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

var replayed : bool

var response : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._ExternalCoreError] | None

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

var governance_context : str | None

var handoff : adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var response : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._SiTerminateSessionResponseBaseAcpHandoff | None

var adcp_error : adcp.types.versioned_bases._v31._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._v31._ExternalCoreError] | None

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

var follow_up : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._SyncAccountsRequestBaseAccountsItemVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._SyncAccountsResponseBaseAccountsItem] | None

var adcp_error : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._SyncAudiencesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._SyncAudiencesRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var audiences : list[adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var audiences : list[adcp.types.versioned_bases._v31._SyncAudiencesResponseBaseAudiencesItem] | None

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

var context_id : str | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._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._v31._SyncCatalogsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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 model_config

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var catalogs : list[adcp.types.versioned_bases._v31._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._v31._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._v31._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 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._v31._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._v31._SyncCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._SyncCreativesRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var assignments : list[adcp.types.versioned_bases._v31._SyncCreativesRequestBaseAssignmentsItem] | None

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

var creative_ids : list[str] | None

var creatives : list[adcp.types.versioned_bases._v31._SyncCreativesRequestBaseCreativesItemVariant1 | adcp.types.versioned_bases._v31._SyncCreativesRequestBaseCreativesItemVariant2]

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._v31._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._v31._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._v31._SyncCreativesResponseBaseCreativesItem] | None

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._SyncEventSourcesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCoreError] | None

var event_sources : list[adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._SyncGovernanceResponseBaseAccountsItem] | None

var adcp_error : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._SyncPlansResponseBasePlansItem]

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._TasksGetRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._TasksGetResponseBaseHistoryItem] | None

var message : str | None

var model_config

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

var progress : adcp.types.versioned_bases._v31._TasksGetResponseBaseProgress | None

var protocol : Literal['media-buy', 'signals', 'governance', 'creative', 'brand', 'sponsored-intelligence', 'measurement']

var push_notification_config : adcp.types.versioned_bases._v31._TasksGetResponseBasePushNotificationConfig | None

var replayed : bool

var result : adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant4 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant5 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant6 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant7 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant8Variant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant8Variant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant8Variant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant9 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant10 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant11 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant12Variant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant12Variant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant12Variant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant13 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant14 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant15 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant16 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant4 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant5 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant17Variant6 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant18 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant19 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant20 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant21Variant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant21Variant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant21Variant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant22 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant23 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant24 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant25Variant1 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant25Variant2 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant25Variant3 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant26 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant27 | adcp.types.versioned_bases._v31._TasksGetResponseBaseResultVariant28 | 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', 'media_buy_delivery', 'sync_creatives', 'build_creative', 'activate_signal', 'get_products', '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']

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._v31._TasksListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._TasksListRequestBaseFilters | None

var include_history : bool

var model_config

var pagination : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._TasksListResponseBasePagination

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

var push_notification_config : adcp.types.versioned_bases._v31._TasksListResponseBasePushNotificationConfig | None

var query_summary : adcp.types.versioned_bases._v31._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._v31._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._v31._UpdateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._UpdateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_collections : list[adcp.types.versioned_bases._v31._UpdateCollectionListRequestBaseBaseCollectionsItemVariant1 | adcp.types.versioned_bases._v31._UpdateCollectionListRequestBaseBaseCollectionsItemVariant2 | adcp.types.versioned_bases._v31._UpdateCollectionListRequestBaseBaseCollectionsItemVariant3] | None

var brand : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCollectionCollectionList

var message : str | None

var model_config

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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._v31._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._v31._UpdateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._UpdateMediaBuyRequestBaseAccountVariant2

var adcp_major_version : int | None

var adcp_version : str | None

var canceled : Literal[True] | None

var cancellation_reason : str | None

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

var end_time : str | None

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

var idempotency_key : str

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

var media_buy_id : str

var model_config

var new_packages : list[adcp.types.versioned_bases._v31._ExternalMediaBuyPackageRequest] | None

var packages : list[adcp.types.versioned_bases._v31._ExternalMediaBuyPackageUpdate] | None

var paused : bool | None

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

var reporting_webhook : adcp.types.versioned_bases._v31._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

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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var affected_packages : list[adcp.types.versioned_bases._v31._ExternalCorePackage] | None

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

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

var context_id : str | None

var currency : str | None

var errors : list[adcp.types.versioned_bases._v31._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._v31._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 payload : dict[str, typing.Any] | None

var push_notification_config : adcp.types.versioned_bases._v31._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['completed', 'canceled', 'rejected'] | 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', 'extend_flight', 'shorten_flight', 'update_flight_dates', 'increase_budget', 'decrease_budget', 'reallocate_budget', 'update_targeting', 'update_pacing', 'update_frequency_caps', 'replace_creative', 'update_creative_assignments', 'remove_creative', 'add_packages', 'remove_packages', 'update_budget', 'update_dates', 'update_packages', 'sync_creatives']] | 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._v31._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._v31._UpdatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._UpdatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var adcp_version : str | None

var base_properties : list[adcp.types.versioned_bases._v31._UpdatePropertyListRequestBaseBasePropertiesItemVariant1 | adcp.types.versioned_bases._v31._UpdatePropertyListRequestBaseBasePropertiesItemVariant2 | adcp.types.versioned_bases._v31._UpdatePropertyListRequestBaseBasePropertiesItemVariant3] | None

var brand : adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalPropertyPropertyList

var message : str | None

var model_config

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

var push_notification_config : adcp.types.versioned_bases._v31._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._v31._UpdateRightsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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 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._v31._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._v31._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._v31._ExternalCoreError] | None

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

var generation_credentials : list[adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var rights_constraint : adcp.types.versioned_bases._v31._ExternalCoreRightsConstraint | 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._v31._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._v31._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._v31._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._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v31._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._v31._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._v31._ValidateInputRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._ValidateInputRequestBaseAccountVariant2 | None

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

var manifest : adcp.types.versioned_bases._v31._ValidateInputRequestBaseManifestVariant1 | adcp.types.versioned_bases._v31._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._v31._ValidateInputRequestBaseTargetsItemVariant1 | adcp.types.versioned_bases._v31._ValidateInputRequestBaseTargetsItemVariant2 | adcp.types.versioned_bases._v31._ValidateInputRequestBaseTargetsItemVariant3] | 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._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v31._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._v31._ValidatePropertyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v31._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._v31._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._v31._ExternalCoreError | None

var adcp_major_version : int | None

var adcp_version : str | None

var aggregate : adcp.types.versioned_bases._v31._ValidatePropertyDeliveryResponseBaseAggregate | None

var authorization_summary : adcp.types.versioned_bases._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v31._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._v31._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._v31._VerifyBrandClaimRequestBaseClaim | adcp.types.versioned_bases._v31._VerifyBrandClaimRequestBaseClaim2 | adcp.types.versioned_bases._v31._VerifyBrandClaimRequestBaseClaim3 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._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._v31._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._v31._VerifyBrandClaimsRequestBaseClaimsItemVariant1 | adcp.types.versioned_bases._v31._VerifyBrandClaimsRequestBaseClaimsItemVariant2 | adcp.types.versioned_bases._v31._VerifyBrandClaimsRequestBaseClaimsItemVariant3 | adcp.types.versioned_bases._v31._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._v31._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._v31._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._v31._ExternalCorePushNotificationConfig | None

var replayed : bool

var results : list[adcp.types.versioned_bases._v31._VerifyBrandClaimsResponseBaseResultsItemVariant1 | adcp.types.versioned_bases._v31._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._v31._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