Module adcp.types.versioned_bases.v30

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 adcp_major_version : int | None

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

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

var revocation_webhook : adcp.types.versioned_bases._v30._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 approval_webhook : adcp.types.versioned_bases._v30._ExternalCorePushNotificationConfig | None

var brand_id : str | None

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

var detail : str | None

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

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

var estimated_response_time : str | None

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

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

var model_config

var reason : str | None

var restrictions : list[str] | None

var rights_constraint : adcp.types.versioned_bases._v30._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['acquired'] | Literal['pending_approval'] | Literal['rejected'] | None

var suggestions : list[str] | None

var terms : adcp.types.versioned_bases._v30._ExternalBrandRightsTerms | 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._v30._ActivateSignalRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ActivateSignalRequestBaseAccountVariant2 | None

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

var adcp_major_version : int | None

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

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

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

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

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

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

var model_config

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]

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._v30._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._v30._BuildCreativeRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._BuildCreativeRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var concept_id : str | None

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

var creative_id : str | None

var creative_manifest : adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest | None

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

var idempotency_key : str

var include_preview : bool | None

var item_limit : int | None

var macro_values : dict[str, str] | None

var media_buy_id : str | None

var message : str | None

var model_config

var package_id : str | None

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

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

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

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

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

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

var target_format_ids : list[adcp.types.versioned_bases._v30._ExternalCoreFormatId] | 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 consumption : adcp.types.versioned_bases._v30._ExternalCoreCreativeConsumption | None

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

var creative_manifest : adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest | None

var creative_manifests : list[adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest] | None

var currency : str | None

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

var expires_at : str | None

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

var model_config

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

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

var pricing_option_id : str | 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 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 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]

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 artifact : adcp.types.versioned_bases._v30._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 confidence : float | None

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

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

var explanation : str | None

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

var features : list[adcp.types.versioned_bases._v30._CalibrateContentResponseBaseFeaturesItem] | 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 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 caller : str

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

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

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

var governance_context : str | None

var invoice_recipient : adcp.types.versioned_bases._v30._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._v30._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 categories_evaluated : list[str] | None

var check_id : str

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

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

var model_config

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

var scenario : Literal['list_scenarios', 'force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format']

var schema_direction : ClassVar[Literal['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 context : dict[str, typing.Any] | 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', 'INTERNAL_ERROR'] | None

var error_detail : str | None

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

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

var message : str | None

var model_config

var previous_state : str | None

var scenarios : list[typing.Literal['force_creative_status', 'force_account_status', 'force_media_buy_status', 'force_create_media_buy_arm', 'force_task_completion', 'force_session_status', 'simulate_delivery', 'simulate_budget_spend', 'seed_product', 'seed_pricing_option', 'seed_creative', 'seed_plan', 'seed_media_buy', 'seed_creative_format']] | 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 success : Literal[True] | Literal[False]

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 artifact : adcp.types.versioned_bases._v30._ExternalContentStandardsArtifact | None

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

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

var geo : adcp.types.versioned_bases._v30._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 cache_ttl : int | None

var model_config

var offers : list[adcp.types.versioned_bases._v30._ExternalTmpOffer]

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._v30._ContextMatchResponseBaseSignals | 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._v30._CreateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._CreateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var brand : adcp.types.versioned_bases._v30._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._v30._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 auth_token : str

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

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

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

var model_config

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 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 calibration_exemplars : adcp.types.versioned_bases._v30._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._v30._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._v30._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 conflicting_standards_id : str | None

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

var errors : list[adcp.types.versioned_bases._v30._ExternalCoreError] | 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 | 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._v30._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._v30._CreateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._CreateMediaBuyRequestBaseAccountVariant2

var adcp_major_version : int | 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._v30._CreateMediaBuyRequestBaseArtifactWebhook | None

var brand : adcp.types.versioned_bases._v30._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._v30._ExternalCoreBusinessEntity | None

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

var model_config

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

var plan_id : str | None

var po_number : str | None

var proposal_id : str | None

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

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

var confirmed_at : str | None

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

var creative_deadline : str | None

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

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

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

var media_buy_id : str | None

var message : str | None

var model_config

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

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

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['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | Literal['submitted'] | None

var task_id : str | None

var valid_actions : list[typing.Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_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 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]

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._v30._CreatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._CreatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var brand : adcp.types.versioned_bases._v30._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._v30._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 auth_token : str

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

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

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

var model_config

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

var creative_format : adcp.types.versioned_bases._v30._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 approved_at : str | None

var conditions : list[str] | None

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

var creative_id : str | None

var creative_url : str | None

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

var estimated_response_time : str | None

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

var model_config

var reason : str | 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['approved'] | Literal['rejected'] | Literal['pending_review'] | None

var status_url : str | None

var suggestions : list[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._v30._DeleteCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._DeleteCollectionListRequestBaseAccountVariant2 | None

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

var deleted : bool

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

var list_id : str

var model_config

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 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._v30._DeletePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._DeletePropertyListRequestBaseAccountVariant2 | None

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

var deleted : bool

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

var list_id : str

var model_config

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 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._v30._GetAccountFinancialsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetAccountFinancialsRequestBaseAccountVariant2

var adcp_major_version : int | None

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

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

var model_config

var period : adcp.types.versioned_bases._v30._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._v30._GetAccountFinancialsResponseBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetAccountFinancialsResponseBaseAccountVariant2 | None

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

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

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

var currency : str | None

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

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

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

var model_config

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._v30._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]

var spend : adcp.types.versioned_bases._v30._GetAccountFinancialsResponseBaseSpend | 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 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._v30._GetAdcpCapabilitiesResponseBaseAccount | None

var adcp : adcp.types.versioned_bases._v30._GetAdcpCapabilitiesResponseBaseAdcp

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

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

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

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

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

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

var last_updated : str | None

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

var model_config

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

var specialisms : list[typing.Literal['audience-sync', 'brand-rights', 'collection-lists', 'content-standards', 'creative-ad-server', 'creative-generative', 'creative-template', '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']] | None

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

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

var webhook_signing : adcp.types.versioned_bases._v30._GetAdcpCapabilitiesResponseBaseWebhookSigning | 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 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 assets : list[adcp.types.versioned_bases._v30._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._v30._GetBrandIdentityResponseBaseColors | None

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

var description : str | None

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

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

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

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

var industries : list[str] | None

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

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

var model_config

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

var rights : adcp.types.versioned_bases._v30._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 tagline : str | list[dict[str, str]] | None

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

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

var voice_synthesis : adcp.types.versioned_bases._v30._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._v30._GetCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 cache_valid_until : str | None

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

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

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

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

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

var model_config

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

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]

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 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 calibration_exemplars : adcp.types.versioned_bases._v30._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 countries_all : list[str] | None

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

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

var languages_any : list[str] | None

var model_config

var name : str | None

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

var pricing_options : list[adcp.types.versioned_bases._v30._GetContentStandardsResponseBasePricingOptionsItemVariant1 | adcp.types.versioned_bases._v30._GetContentStandardsResponseBasePricingOptionsItemVariant2 | adcp.types.versioned_bases._v30._GetContentStandardsResponseBasePricingOptionsItemVariant3 | adcp.types.versioned_bases._v30._GetContentStandardsResponseBasePricingOptionsItemVariant4 | adcp.types.versioned_bases._v30._GetContentStandardsResponseBasePricingOptionsItemVariant5] | 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 standards_id : 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._v30._GetCreativeDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetCreativeDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 context : dict[str, typing.Any] | None

var creatives : list[adcp.types.versioned_bases._v30._GetCreativeDeliveryResponseBaseCreativesItem]

var currency : str

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

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

var media_buy_id : str | None

var model_config

var pagination : adcp.types.versioned_bases._v30._GetCreativeDeliveryResponseBasePagination | None

var reporting_period : adcp.types.versioned_bases._v30._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]

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._v30._GetCreativeFeaturesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetCreativeFeaturesRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var creative_manifest : adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest

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 consumption : adcp.types.versioned_bases._v30._ExternalCoreCreativeConsumption | None

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

var currency : str | None

var detail_url : str | None

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

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

var model_config

var pricing_option_id : str | None

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

var adcp_major_version : int | 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._v30._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._v30._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 artifacts : list[adcp.types.versioned_bases._v30._GetMediaBuyArtifactsResponseBaseArtifactsItem] | None

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

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

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

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

var media_buy_id : str | None

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 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._v30._GetMediaBuyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetMediaBuyDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var model_config

var reporting_dimensions : adcp.types.versioned_bases._v30._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

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 aggregated_totals : adcp.types.versioned_bases._v30._GetMediaBuyDeliveryResponseBaseAggregatedTotals | None

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

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

var currency : str

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

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

var media_buy_deliveries : list[adcp.types.versioned_bases._v30._GetMediaBuyDeliveryResponseBaseMediaBuyDeliveriesItem]

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 reporting_period : adcp.types.versioned_bases._v30._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 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._v30._GetMediaBuysRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetMediaBuysRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

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

var include_history : int

var include_snapshot : bool

var media_buy_ids : list[str] | None

var model_config

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

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

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

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

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

var model_config

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

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

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

var model_config

var plans : list[adcp.types.versioned_bases._v30._GetPlanAuditLogsResponseBasePlansItem]

var schema_direction : ClassVar[Literal['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 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._v30._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._v30._GetProductsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetProductsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var brief : str | None

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

var catalog : adcp.types.versioned_bases._v30._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', 'format_ids', 'placements', 'delivery_type', 'exclusivity', 'pricing_options', 'forecast', 'outcome_measurement', 'delivery_measurement', 'reporting_capabilities', 'creative_policy', 'catalog_types', 'metric_optimization', 'conversion_tracking', 'data_provider_signals', '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._v30._ExternalCoreProductFilters | None

var model_config

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

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

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

var refine : list[adcp.types.versioned_bases._v30._GetProductsRequestBaseRefineItemVariant1 | adcp.types.versioned_bases._v30._GetProductsRequestBaseRefineItemVariant2 | adcp.types.versioned_bases._v30._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._v30._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 catalog_applied : bool | None

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

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

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

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

var model_config

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

var products : list[adcp.types.versioned_bases._v30._ExternalCoreProduct]

var property_list_applied : bool | None

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

var refinement_applied : list[adcp.types.versioned_bases._v30._GetProductsResponseBaseRefinementAppliedItemVariant1 | adcp.types.versioned_bases._v30._GetProductsResponseBaseRefinementAppliedItemVariant2 | adcp.types.versioned_bases._v30._GetProductsResponseBaseRefinementAppliedItemVariant3] | 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]

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 estimated_completion : str | 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]

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._v30._GetPropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetPropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 cache_valid_until : str | None

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

var coverage_gaps : dict[str, list[adcp.types.versioned_bases._v30._ExternalCoreIdentifier]] | None

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

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

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

var model_config

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

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]

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 brand_id : str | None

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

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

var excluded : list[adcp.types.versioned_bases._v30._GetRightsResponseBaseExcludedItem] | None

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

var model_config

var rights : list[adcp.types.versioned_bases._v30._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]

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._v30._GetSignalsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._GetSignalsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

var countries : list[str] | None

var destinations : list[adcp.types.versioned_bases._v30._GetSignalsRequestBaseDestinationsItemVariant1 | adcp.types.versioned_bases._v30._GetSignalsRequestBaseDestinationsItemVariant2] | None

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

var filters : adcp.types.versioned_bases._v30._ExternalCoreSignalFilters | None

var max_results : int | None

var model_config

var pagination : adcp.types.versioned_bases._v30._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 signal_ids : list[adcp.types.versioned_bases._v30._GetSignalsRequestBaseSignalIdsItemVariant1 | adcp.types.versioned_bases._v30._GetSignalsRequestBaseSignalIdsItemVariant2] | 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 context : dict[str, typing.Any] | None

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 signals : list[adcp.types.versioned_bases._v30._GetSignalsResponseBaseSignalsItem]

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 consent : adcp.types.versioned_bases._v30._IdentityMatchRequestBaseConsent | None

var country : str | None

var identities : list[adcp.types.versioned_bases._v30._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 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 eligible_package_ids : list[str]

var model_config

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 tmpx : str | 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 adcp_major_version : int | None

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

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

var model_config

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

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

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 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._v30._ListCollectionListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ListCollectionListsRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 context : dict[str, typing.Any] | None

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

var lists : list[adcp.types.versioned_bases._v30._ExternalCollectionCollectionList]

var model_config

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

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 standards : list[adcp.types.versioned_bases._v30._ExternalContentStandardsContentStandards] | 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._v30._ListCreativeFormatsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ListCreativeFormatsRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

var asset_types : list[typing.Literal['image', 'video', 'audio', 'text', 'html', 'javascript', 'url']] | 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._v30._ExternalCoreFormatId] | None

var include_pricing : bool

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

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

var creative_agents : list[adcp.types.versioned_bases._v30._ListCreativeFormatsResponseBaseCreativeAgentsItem] | None

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

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 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._v30._ListCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ListCreativesRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._ExternalCoreCreativeFilters | None

var include_assignments : bool

var include_items : bool

var include_pricing : bool

var include_snapshot : bool

var include_variables : bool

var model_config

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

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

var creatives : list[adcp.types.versioned_bases._v30._ListCreativesResponseBaseCreativesItem]

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

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse

var query_summary : adcp.types.versioned_bases._v30._ListCreativesResponseBaseQuerySummary

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_summary : adcp.types.versioned_bases._v30._ListCreativesResponseBaseStatusSummary | 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._v30._ListPropertyListsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ListPropertyListsRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 context : dict[str, typing.Any] | None

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

var lists : list[adcp.types.versioned_bases._v30._ExternalPropertyPropertyList]

var model_config

var pagination : adcp.types.versioned_bases._v30._ExternalCorePaginationResponse | 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 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 context : dict[str, typing.Any] | None

var event_source_id : str

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

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

var events_processed : int | None

var events_received : int | None

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

var match_quality : float | None

var model_config

var partial_failures : list[adcp.types.versioned_bases._v30._LogEventResponseBasePartialFailuresItem] | 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 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 agency_estimate_number : str | None

var bid_price : float | None

var budget : float

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

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

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

var creatives : list[adcp.types.versioned_bases._v30._ExternalCoreCreativeAsset] | None

var end_time : str | None

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

var format_ids : list[adcp.types.versioned_bases._v30._ExternalCoreFormatId] | None

var impressions : float | None

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

var model_config

var optimization_goals : list[adcp.types.versioned_bases._v30._PackageRequestBaseOptimizationGoalsItemVariant1 | adcp.types.versioned_bases._v30._PackageRequestBaseOptimizationGoalsItemVariant2] | None

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

var paused : bool

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

var creative_id : str | None

var creative_manifest : adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest | None

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

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

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

var creative_id : str | None

var expires_at : str | None

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

var interactive_url : str | None

var manifest : adcp.types.versioned_bases._v30._ExternalCoreCreativeManifest | None

var model_config

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

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

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

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

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

var model_config

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

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 check_id : str | None

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

var delivery : adcp.types.versioned_bases._v30._ReportPlanOutcomeRequestBaseDelivery | None

var error : adcp.types.versioned_bases._v30._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._v30._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 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._v30._ReportPlanOutcomeResponseBaseFindingsItem] | None

var model_config

var outcome_id : str

var plan_summary : adcp.types.versioned_bases._v30._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]

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

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

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

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

var model_config

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]

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 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 alternative_offering_ids : list[str] | None

var available : bool

var checked_at : str | None

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

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

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

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

var model_config

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

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

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

var idempotency_key : str

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

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

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

var model_config

var negotiated_capabilities : adcp.types.versioned_bases._v30._ExternalSponsoredIntelligenceSiCapabilities | None

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

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._v30._SiSendMessageRequestBaseActionResponse | None

var adcp_major_version : int | 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

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

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

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

var handoff : adcp.types.versioned_bases._v30._SiSendMessageResponseBaseHandoff | None

var mcp_resource_uri : str | None

var model_config

var response : adcp.types.versioned_bases._v30._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']

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 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._v30._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._v30._SiTerminateSessionResponseBaseAcpHandoff | None

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

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

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

var follow_up : adcp.types.versioned_bases._v30._SiTerminateSessionResponseBaseFollowUp | 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 session_status : Literal['active', 'pending_handoff', 'complete', 'terminated'] | None

var terminated : bool

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._v30._SyncAccountsRequestBaseAccountsItem]

var adcp_major_version : int | 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._v30._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._v30._SyncAccountsResponseBaseAccountsItem] | None

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

var dry_run : bool | None

var errors : list[adcp.types.versioned_bases._v30._ExternalCoreError] | 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]

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._v30._SyncAudiencesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._SyncAudiencesRequestBaseAccountVariant2

var adcp_major_version : int | None

var audiences : list[adcp.types.versioned_bases._v30._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 audiences : list[adcp.types.versioned_bases._v30._SyncAudiencesResponseBaseAudiencesItem] | None

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

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

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

var model_config

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]

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._v30._SyncCatalogsRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._SyncCatalogsRequestBaseAccountVariant2

var adcp_major_version : int | None

var catalog_ids : list[str] | None

var catalogs : list[adcp.types.versioned_bases._v30._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._v30._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 catalogs : list[adcp.types.versioned_bases._v30._SyncCatalogsResponseBaseCatalogsItem] | None

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

var dry_run : bool | None

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

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

var model_config

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]

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 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]

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._v30._SyncCreativesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._SyncCreativesRequestBaseAccountVariant2

var adcp_major_version : int | None

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

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

var creative_ids : list[str] | None

var creatives : list[adcp.types.versioned_bases._v30._ExternalCoreCreativeAsset]

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

var creatives : list[adcp.types.versioned_bases._v30._SyncCreativesResponseBaseCreativesItem] | None

var dry_run : bool | None

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

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

var message : str | None

var model_config

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'] | None

var task_id : 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 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]

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._v30._SyncEventSourcesRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._SyncEventSourcesRequestBaseAccountVariant2

var adcp_major_version : int | None

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

var delete_missing : bool

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

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

var event_sources : list[adcp.types.versioned_bases._v30._SyncEventSourcesResponseBaseEventSourcesItem] | None

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

var model_config

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]

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._v30._SyncGovernanceRequestBaseAccountsItem]

var adcp_major_version : int | 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._v30._SyncGovernanceResponseBaseAccountsItem] | None

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

var errors : list[adcp.types.versioned_bases._v30._ExternalCoreError] | 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]

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

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

var model_config

var plans : list[adcp.types.versioned_bases._v30._SyncPlansResponseBasePlansItem]

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 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 adcp_major_version : int | None

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

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

var include_history : 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 completed_at : str | None

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

var created_at : str

var error : adcp.types.versioned_bases._v30._TasksGetResponseBaseError | None

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

var has_webhook : bool | None

var history : list[adcp.types.versioned_bases._v30._TasksGetResponseBaseHistoryItem] | None

var model_config

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

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

var schema_direction : ClassVar[Literal['request', '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', 'sync_creatives', 'activate_signal', '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', 'get_rights', 'acquire_rights']

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 adcp_major_version : int | None

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

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

var filters : adcp.types.versioned_bases._v30._TasksListRequestBaseFilters | None

var include_history : bool

var model_config

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

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

var model_config

var pagination : adcp.types.versioned_bases._v30._TasksListResponseBasePagination

var query_summary : adcp.types.versioned_bases._v30._TasksListResponseBaseQuerySummary

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

var tasks : list[adcp.types.versioned_bases._v30._TasksListResponseBaseTasksItem]

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._v30._UpdateCollectionListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._UpdateCollectionListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

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

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

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

var model_config

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 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 calibration_exemplars : adcp.types.versioned_bases._v30._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._v30._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._v30._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 conflicting_standards_id : str | None

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

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

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

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._v30._UpdateMediaBuyRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._UpdateMediaBuyRequestBaseAccountVariant2

var adcp_major_version : int | 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._v30._ExternalCoreBusinessEntity | None

var media_buy_id : str

var model_config

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

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

var paused : bool | None

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

var reporting_webhook : adcp.types.versioned_bases._v30._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 affected_packages : list[adcp.types.versioned_bases._v30._ExternalCorePackage] | None

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

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

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

var implementation_date : str | None

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

var media_buy_id : str | None

var model_config

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['pending_creatives', 'pending_start', 'active', 'paused', 'completed', 'rejected', 'canceled'] | None

var valid_actions : list[typing.Literal['pause', 'resume', 'cancel', 'update_budget', 'update_dates', 'update_packages', 'add_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 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]

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._v30._UpdatePropertyListRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._UpdatePropertyListRequestBaseAccountVariant2 | None

var adcp_major_version : int | None

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

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

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

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

var model_config

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

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

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

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

var implementation_date : str | None

var model_config

var paused : bool | None

var rights_constraint : adcp.types.versioned_bases._v30._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 terms : adcp.types.versioned_bases._v30._ExternalBrandRightsTerms | 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 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._v30._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 context : dict[str, typing.Any] | None

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

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

var model_config

var results : list[adcp.types.versioned_bases._v30._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 summary : adcp.types.versioned_bases._v30._ValidateContentDeliveryResponseBaseSummary | 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._v30._ValidatePropertyDeliveryRequestBaseAccountVariant1 | adcp.types.versioned_bases._v30._ValidatePropertyDeliveryRequestBaseAccountVariant2 | None

var adcp_major_version : int | 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._v30._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 aggregate : adcp.types.versioned_bases._v30._ValidatePropertyDeliveryResponseBaseAggregate | None

var authorization_summary : adcp.types.versioned_bases._v30._ValidatePropertyDeliveryResponseBaseAuthorizationSummary | None

var compliant : bool | None

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

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

var list_id : str

var list_resolved_at : str | None

var model_config

var results : list[adcp.types.versioned_bases._v30._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 summary : adcp.types.versioned_bases._v30._ValidatePropertyDeliveryResponseBaseSummary

var validated_at : str