Module adcp.types.canonical_creative

Canonical-first creative models for the Python 7 public API.

The generated protocol models intentionally remain wire-faithful through the AdCP 3.x transition and therefore contain legacy named-format identity. They are exposed from :mod:adcp.types.legacy. This module provides the primary application-facing models: legacy identity is absent from their declared fields, JSON Schema, and serialized output at every nesting depth.

Functions

def is_legacy_creative_identity_key(key: object) ‑> bool

Expand source code

def is_legacy_creative_identity_key(key: object) -> bool:
    """Return whether *key* names legacy creative routing identity."""

    return isinstance(key, str) and bool(_LEGACY_IDENTITY_KEY.search(key))

Return whether key names legacy creative routing identity.

def sanitize_canonical_schema(schema: dict[str, Any]) ‑> dict[str, typing.Any]

Expand source code

def sanitize_canonical_schema(schema: dict[str, Any]) -> dict[str, Any]:
    """Return a defensive deep copy with legacy identity removed."""

    return _sanitize_schema_node(copy.deepcopy(schema))

Return a defensive deep copy with legacy identity removed.

def strip_legacy_creative_identity(value: Any) ‑> Any

Expand source code

def strip_legacy_creative_identity(
    value: Any,
    *,
    _path: str = "$",
    _format_scope: bool = False,
) -> Any:
    """Recursively remove legacy creative identity from a serialized value.

    This is deliberately a runtime boundary rather than a typing convention.
    Unknown extension bags are traversed too, so ``extra='allow'`` can never be
    used to smuggle ``format_id`` or ``format_ids`` through a primary model.
    """

    if isinstance(value, dict):
        legacy_tuple = _is_format_scoped_agent_tuple(
            value,
            path=_path,
        )
        return {
            key: strip_legacy_creative_identity(
                item,
                _path=f"{_path}.{key}",
                _format_scope=_format_scope or (isinstance(key, str) and "format" in key.lower()),
            )
            for key, item in value.items()
            if not is_legacy_creative_identity_key(key)
            and not (legacy_tuple and key == "agent_url")
        }
    if isinstance(value, list):
        return [
            strip_legacy_creative_identity(
                item,
                _path=f"{_path}[{index}]",
                _format_scope=_format_scope,
            )
            for index, item in enumerate(value)
        ]
    if isinstance(value, tuple):
        return tuple(
            strip_legacy_creative_identity(
                item,
                _path=f"{_path}[{index}]",
                _format_scope=_format_scope,
            )
            for index, item in enumerate(value)
        )
    return value

Recursively remove legacy creative identity from a serialized value.

This is deliberately a runtime boundary rather than a typing convention. Unknown extension bags are traversed too, so extra='allow' can never be used to smuggle format_id or format_ids through a primary model.

Classes

class CanonicalBoundaryModel (**data: Any)

Expand source code

class CanonicalBoundaryModel(AdCPBaseModel):
    """Base class enforcing the primary canonical runtime boundary."""

    model_config = ConfigDict(extra="allow", defer_build=True)
    __adcp_canonical_creative_model__: ClassVar[bool] = True

    @model_validator(mode="before")
    @classmethod
    def _reject_legacy_creative_identity(cls, value: Any) -> Any:
        found = _legacy_creative_identity_path(
            value,
            allow_root_v1_ref=cls.__name__ == "Format",
            format_scope=cls.__name__ == "Format",
        )
        if found is not None:
            raise ValueError(
                f"{found} contains legacy creative identity; use an explicit Legacy* model"
            )
        return value

    def model_dump(self, **kwargs: Any) -> dict[str, Any]:
        kwargs.setdefault("serialize_as_any", False)
        return strip_legacy_creative_identity(
            super().model_dump(**kwargs),
            _format_scope=self.__class__.__name__ == "Format",
        )

    def model_dump_json(self, **kwargs: Any) -> str:
        kwargs.setdefault("serialize_as_any", False)
        raw = super().model_dump_json(**kwargs)
        clean = strip_legacy_creative_identity(
            json.loads(raw),
            _format_scope=self.__class__.__name__ == "Format",
        )
        indent = kwargs.get("indent")
        return json.dumps(
            clean,
            ensure_ascii=False,
            indent=indent,
            separators=None if indent is not None else (",", ":"),
        )

    @classmethod
    def model_json_schema(cls, *args: Any, **kwargs: Any) -> dict[str, Any]:
        return sanitize_canonical_schema(super().model_json_schema(*args, **kwargs))

    @classmethod
    def __get_pydantic_json_schema__(
        cls,
        core_schema: CoreSchema,
        handler: GetJsonSchemaHandler,
    ) -> dict[str, Any]:
        """Enforce the boundary for TypeAdapter and containing-model schemas."""

        schema = sanitize_canonical_schema(handler(core_schema))
        # TypeAdapter assembles shared definitions outside the model's returned
        # node. Mutate the active generator's definition registry as well so
        # unreachable generated legacy definitions cannot leak into the final
        # recursive schema document.
        generator = handler.generate_json_schema
        for key, definition in list(generator.definitions.items()):
            generator.definitions[key] = sanitize_canonical_schema(definition)
        return schema

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Subclasses

• CreateMediaBuyRequest
• CreateMediaBuyResponse2
• CreateMediaBuyResponse3
• Creative
• CreativeAsset
• CreativeFilters
• CreativeVariant
• DeliveryCreative
• Format
• GetCreativeDeliveryResponse
• GetMediaBuyDeliveryResponse
• GetMediaBuysResponse
• GetProductsResponse
• ListCreativesResponse
• MediaBuy
• MediaBuyPackage
• Package
• PackageRequest
• PackageUpdate
• Placement
• Product
• ProductFilters
• SyncCreativesRequest
• UpdateMediaBuyRequest
• UpdateMediaBuyResponse2
• UpdateMediaBuyResponse3
• adcp.types.canonical_creative._CreateMediaBuyResponse1Base
• adcp.types.canonical_creative._CreativeManifestBase
• adcp.types.canonical_creative._GetProductsRequestBase
• adcp.types.canonical_creative._ListCreativesRequestBase
• adcp.types.canonical_creative._UpdateMediaBuyResponse1Base

Class variables

var model_config

Static methods

def model_json_schema(*args: Any, **kwargs: Any) ‑> dict[str, typing.Any]

Generates a JSON schema for a model class.

Args

-----=

by_alias

Whether to use attribute aliases or not.

ref_template

The reference template.

union_format

The format to use when combining schemas from unions together. Can be one of:

• 'any_of': Use the anyOf keyword to combine schemas (the default).
• 'primitive_type_array': Use the type keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive type (string, boolean, null, integer or number) or contains constraints/metadata, falls back to any_of.

schema_generator

To override the logic used to generate the JSON schema, as a subclass of GenerateJsonSchema with your desired modifications

mode

The mode in which to generate the schema.

Returns -----= The JSON schema for the given model class.

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class CreateMediaBuyRequest (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.generated_poc.core.account_ref.AccountReference

var adcp_major_version : int | None

var adcp_version : str | None

var advertiser_industry : adcp.types.generated_poc.enums.advertiser_industry.AdvertiserIndustry | None

var agency_estimate_number : str | None

var artifact_webhook : adcp.types.generated_poc.media_buy.create_media_buy_request.ArtifactWebhook | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var brand : adcp.types.generated_poc.core.brand_ref.BrandReference

var budget_allocation : adcp.types.generated_poc.core.budget_allocation.BudgetAllocation | None

var budget_cap_timezone : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var idempotency_key : str

var invoice_recipient : adcp.types.generated_poc.core.business_entity.BusinessEntity | None

var io_acceptance : adcp.types.generated_poc.media_buy.create_media_buy_request.IoAcceptance | None

var model_config

var name : str | None

var opportunity : adcp.types.generated_poc.media_buy.create_media_buy_request.Opportunity | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var packages : list[PackageRequest] | None

var paused : bool | None

var plan_id : str | None

var po_number : str | None

var proposal_id : str | None

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var reporting_webhook : adcp.types.generated_poc.core.reporting_webhook.ReportingWebhook | None

var start_time : adcp.types.generated_poc.core.start_timing.StartTiming

var total_budget : adcp.types.generated_poc.media_buy.create_media_buy_request.TotalBudget | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreateMediaBuyResponse1 (**data: Any)

Expand source code

class CreateMediaBuyResponse1(_CreateMediaBuyResponse1Base):
    """Canonical create response preserving the 3.x legacy-status normalizer."""

    @model_validator(mode="before")
    @classmethod
    def _normalize_legacy_status(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        raw_status = unwrap_enum_value(data.get("status"))
        media_buy_status = unwrap_enum_value(data.get("media_buy_status"))
        if raw_status is None or raw_status == "completed":
            return {**data, "status": "completed"}
        if media_buy_status is None and raw_status in MEDIA_BUY_LEGACY_STATUS_VALUES:
            return {**data, "media_buy_status": raw_status, "status": "completed"}
        if media_buy_status is not None and raw_status == media_buy_status:
            return {**data, "status": "completed"}
        return data

Canonical create response preserving the 3.x legacy-status normalizer.

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

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

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

Ancestors

• adcp.types.canonical_creative._CreateMediaBuyResponse1Base
• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreateMediaBuyResponse2 (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var errors : list[adcp.types.generated_poc.core.error.Error]

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreateMediaBuyResponse3 (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var message : str | None

var model_config

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var replayed : bool | None

var status : Literal[]

var task_id : str

var timestamp : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class Creative (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.generated_poc.core.account.Account | None

var assets : dict[str, adcp.types.generated_poc.core.assets.asset_union.AssetVariant | adcp.types.generated_poc.creative.list_creatives_response.Assets] | None

var assignments : adcp.types.generated_poc.creative.list_creatives_response.Assignments1 | None

var concept_id : str | None

var concept_name : str | None

var created_date : pydantic.types.AwareDatetime

var creative_id : str

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind

var format_option_ref : adcp.types.generated_poc.core.format_option_ref.FormatOptionReference | None

var items : list[adcp.types.generated_poc.core.creative_item.CreativeItem] | None

var localization : adcp.types.generated_poc.core.creative_localization_readback.CreativeLocalizationReadback | None

var localization_unavailable : adcp.types.generated_poc.creative.list_creatives_response.LocalizationUnavailable | None

var model_config

var name : str

var pricing_options : list[adcp.types.generated_poc.core.vendor_pricing_option.VendorPricingOption] | None

var purge : adcp.types.generated_poc.creative.list_creatives_response.Purge | None

var rights : list[adcp.types.generated_poc.core.rights_constraint.RightsConstraint] | None

var rights_attestation_evaluations : list[adcp.types.generated_poc.core.rights_attestation_evaluation.RightsAttestationEvaluation] | None

var snapshot : adcp.types.generated_poc.creative.list_creatives_response.Snapshot | None

var snapshot_unavailable_reason : adcp.types.generated_poc.enums.snapshot_unavailable_reason.SnapshotUnavailableReason | None

var status : adcp.types.generated_poc.enums.creative_status.CreativeStatus

var tags : list[str] | None

var updated_date : pydantic.types.AwareDatetime

var variables : list[adcp.types.generated_poc.core.creative_variable.CreativeVariable] | None

var webhook_activity : list[adcp.types.generated_poc.core.webhook_activity_record.WebhookActivityRecord] | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreativeAsset (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var assets : dict[str, adcp.types.generated_poc.core.assets.asset_union.AssetVariant | adcp.types.generated_poc.core.creative_asset.Assets]

var creative_id : str

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind

var format_option_ref : adcp.types.generated_poc.core.format_option_ref.FormatOptionReference | None

var industry_identifiers : list[adcp.types.generated_poc.core.industry_identifier.IndustryIdentifier] | None

var inputs : list[adcp.types.generated_poc.core.creative_asset.Input] | None

var model_config

var name : str

var placement_ids : list[str] | None

var placement_refs : list[adcp.types.generated_poc.core.placement_ref.PlacementReference] | None

var provenance : adcp.types.generated_poc.core.provenance.Provenance | None

var rights : list[adcp.types.generated_poc.core.rights_constraint.RightsConstraint] | None

var status : adcp.types.generated_poc.enums.creative_status.CreativeStatus | None

var tags : list[str] | None

var weight : float | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreativeFilters (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var accounts : list[adcp.types.generated_poc.core.account_ref.AccountReference] | None

var asset_types : list[adcp.types.generated_poc.enums.asset_content_type.AssetContentType] | None

var assigned_to_packages : list[str] | None

var concept_ids : list[str] | None

var created_after : pydantic.types.AwareDatetime | None

var created_before : pydantic.types.AwareDatetime | None

var creative_ids : list[str] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var format_kinds : list[adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind] | None

var has_served : bool | None

var has_variables : bool | None

var indicator_types : list[adcp.types.generated_poc.enums.indicator_type.IndicatorType] | None

var media_buy_ids : list[str] | None

var model_config

var name_contains : str | None

var statuses : list[adcp.types.generated_poc.enums.creative_status.CreativeStatus] | None

var tags : list[str] | None

var tags_any : list[str] | None

var unassigned : bool | None

var updated_after : pydantic.types.AwareDatetime | None

var updated_before : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreativeManifest (**data: Any)

Expand source code

class CreativeManifest(_CreativeManifestBase):
    """Canonical manifest accepting the SDK's public standalone asset models.

    The 3.2 aggregate asset-union schema currently generates structurally
    duplicate Pydantic classes. Convert public ``ImageContent``/``UrlContent``
    (and peers) back to their wire dictionaries before the aggregate union
    validates them. This keeps the public constructors composable without
    relaxing the on-wire discriminator checks.
    """

    @model_validator(mode="before")
    @classmethod
    def _normalize_standalone_assets(cls, data: Any) -> Any:
        if not isinstance(data, dict) or not isinstance(data.get("assets"), dict):
            return data

        def wire_value(value: Any) -> Any:
            if isinstance(value, AdCPBaseModel):
                return value.model_dump(mode="json", exclude_none=True)
            if isinstance(value, list):
                return [wire_value(item) for item in value]
            return value

        return {
            **data,
            "assets": {key: wire_value(value) for key, value in data["assets"].items()},
        }

Canonical manifest accepting the SDK's public standalone asset models.

The 3.2 aggregate asset-union schema currently generates structurally duplicate Pydantic classes. Convert public ImageContent/UrlContent (and peers) back to their wire dictionaries before the aggregate union validates them. This keeps the public constructors composable without relaxing the on-wire discriminator checks.

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

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

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

Ancestors

• adcp.types.canonical_creative._CreativeManifestBase
• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class CreativeVariant (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var brand_lift : float | None

var brand_search_lift : float | None

var by_action_source : list[adcp.types.generated_poc.core.delivery_metrics.ByActionSourceItem] | None

var by_event_type : list[adcp.types.generated_poc.core.delivery_metrics.ByEventTypeItem] | None

var clicks : float | None

var commissionable_value : float | None

var completed_views : float | None

var completion_rate : float | None

var conversion_lift : float | None

var conversion_value : float | None

var conversions : float | None

var cost_per_acquisition : float | None

var cost_per_click : float | None

var cost_per_completed_view : float | None

var cpm : float | None

var ctr : float | None

var dooh_metrics : adcp.types.generated_poc.core.delivery_metrics.DoohMetrics | None

var downloads : float | None

var engagement_rate : float | None

var engagements : float | None

var follows : float | None

var foot_traffic : float | None

var frequency : float | None

var generation_context : adcp.types.generated_poc.core.creative_variant.GenerationContext | None

var grps : float | None

var impressions : float | None

var incremental_sales_lift : float | None

var leads : float | None

var locale_variant_id : str | None

var manifest : CreativeManifest | None

var model_config

var new_to_brand_rate : float | None

var new_to_brand_units : float | None

var plays : float | None

var profile_visits : float | None

var quartile_data : adcp.types.generated_poc.core.delivery_metrics.QuartileData | None

var reach : float | None

var reach_unit : adcp.types.generated_poc.enums.reach_unit.ReachUnit | None

var reach_window : adcp.types.generated_poc.core.delivery_metrics.ReachWindow | None

var roas : float | None

var saves : float | None

var spend : float | None

var units_sold : float | None

var variant_id : str

var vendor_metric_values : list[adcp.types.generated_poc.core.vendor_metric_value.VendorMetricValue] | None

var viewability : adcp.types.generated_poc.core.delivery_metrics.Viewability | None

var views : float | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class DeliveryCreative (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var creative_id : str

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind | None

var format_option_ref : adcp.types.generated_poc.core.format_option_ref.FormatOptionReference | None

var media_buy_id : str | None

var model_config

var totals : adcp.types.generated_poc.core.delivery_metrics.DeliveryMetrics | None

var variant_count : int | None

var variants : list[CreativeVariant]

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class Format (**data: Any)

Expand source code

class Format(CanonicalBoundaryModel):
    """Canonical format declaration exposed as ``adcp.Format``."""

    format_option_id: str | None = Field(
        default=None,
        description="Stable option identifier within the product or publisher namespace.",
    )
    publisher_domain: str | None = Field(
        default=None,
        pattern=r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$",
    )
    display_name: str | None = None
    applies_to_channels: list[MediaChannel] | None = None
    seller_preference: SellerPreference | None = None
    canonical_formats_only: bool | None = None
    experimental: bool | None = None
    format_shape: str | None = None
    format_schema: PlatformExtensionReference | None = None
    format_kind: CanonicalFormatKind
    params: dict[str, Any]

    _legacy_format_refs: list[LegacyFormatId] = PrivateAttr(default_factory=list)

    _serialize_canonical = model_serializer(mode="wrap")(_serialize_canonical_model)

    @model_validator(mode="before")
    @classmethod
    def _reject_legacy_conflicts_and_credentials(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        if data.get("canonical_formats_only") is True and data.get("v1_format_ref"):
            raise ValueError(
                "canonical_formats_only=True is mutually exclusive with legacy v1_format_ref"
            )
        for bag_name, bag in (
            ("params", data.get("params")),
            (
                "extras",
                {
                    key: value
                    for key, value in data.items()
                    if key not in cls.model_fields and key != "v1_format_ref"
                },
            ),
        ):
            found = _walk_for_credential_keys(bag, path=bag_name)
            if found is not None:
                raise ValueError(
                    f"{found!r} matches a credential-shaped key suffix and cannot "
                    "be stored in a canonical format declaration"
                )
        return data

    def __init__(self, **data: Any) -> None:
        refs = data.get("v1_format_ref")
        if "capability_id" in data and "format_option_id" not in data:
            data["format_option_id"] = data.pop("capability_id")
        super().__init__(**data)
        if self.__pydantic_extra__ is not None:
            self.__pydantic_extra__.pop("v1_format_ref", None)
        if refs:
            self._legacy_format_refs = [
                LegacyFormatId.model_validate(copy.deepcopy(ref)) for ref in refs
            ]

    @property
    def legacy_format_refs(self) -> tuple[LegacyFormatId, ...]:
        """Original tuples retained only for an explicit compatibility adapter."""

        return tuple(copy.deepcopy(ref) for ref in self._legacy_format_refs)

    def params_as(self, canonical_type: type[_CanonicalParamsT]) -> _CanonicalParamsT:
        """Validate the open parameter bag against a typed canonical model."""

        return canonical_type.model_validate(self.params)

    @model_validator(mode="after")
    def _validate_custom_shape(self) -> Format:
        if self.format_kind is CanonicalFormatKind.custom:
            if not self.format_shape:
                raise ValueError("custom formats require format_shape")
        elif self.format_shape is not None or self.format_schema is not None:
            raise ValueError("format_shape and format_schema are only valid for custom formats")
        return self

Canonical format declaration exposed as Format.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var applies_to_channels : list[adcp.types.generated_poc.enums.channels.MediaChannel] | None

var canonical_formats_only : bool | None

var display_name : str | None

var experimental : bool | None

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind

var format_option_id : str | None

var format_schema : adcp.types.generated_poc.core.platform_extension_ref.PlatformExtensionReference | None

var format_shape : str | None

var model_config

var params : dict[str, typing.Any]

var publisher_domain : str | None

var seller_preference : adcp.types.generated_poc.core.product_format_declaration.SellerPreference | None

Instance variables

prop legacy_format_refs : tuple[LegacyFormatId, ...]

Expand source code

@property
def legacy_format_refs(self) -> tuple[LegacyFormatId, ...]:
    """Original tuples retained only for an explicit compatibility adapter."""

    return tuple(copy.deepcopy(ref) for ref in self._legacy_format_refs)

Original tuples retained only for an explicit compatibility adapter.

Methods

def model_post_init(self: BaseModel, context: Any, /) ‑> None

Expand source code

def init_private_attributes(self: BaseModel, context: Any, /) -> None:
    """This function is meant to behave like a BaseModel method to initialize private attributes.

    It takes context as an argument since that's what pydantic-core passes when calling it.

    Args:
        self: The BaseModel instance.
        context: The context.
    """
    if getattr(self, '__pydantic_private__', None) is None:
        pydantic_private = {}
        for name, private_attr in self.__private_attributes__.items():
            # Avoid needlessly creating a new dict for the validated data:
            if private_attr.default_factory_takes_validated_data:
                default = private_attr.get_default(
                    call_default_factory=True, validated_data={**self.__dict__, **pydantic_private}
                )
            else:
                default = private_attr.get_default(call_default_factory=True)
            if default is not PydanticUndefined:
                pydantic_private[name] = default
        object_setattr(self, '__pydantic_private__', pydantic_private)

This function is meant to behave like a BaseModel method to initialize private attributes.

It takes context as an argument since that's what pydantic-core passes when calling it.

Args

-----=

self

The BaseModel instance.

context

The context.

def params_as(self, canonical_type: type[_CanonicalParamsT]) ‑> ~_CanonicalParamsT

Expand source code

def params_as(self, canonical_type: type[_CanonicalParamsT]) -> _CanonicalParamsT:
    """Validate the open parameter bag against a typed canonical model."""

    return canonical_type.model_validate(self.params)

Validate the open parameter bag against a typed canonical model.

class ProductFormatDeclaration (**data: Any)

Expand source code

class Format(CanonicalBoundaryModel):
    """Canonical format declaration exposed as ``adcp.Format``."""

    format_option_id: str | None = Field(
        default=None,
        description="Stable option identifier within the product or publisher namespace.",
    )
    publisher_domain: str | None = Field(
        default=None,
        pattern=r"^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$",
    )
    display_name: str | None = None
    applies_to_channels: list[MediaChannel] | None = None
    seller_preference: SellerPreference | None = None
    canonical_formats_only: bool | None = None
    experimental: bool | None = None
    format_shape: str | None = None
    format_schema: PlatformExtensionReference | None = None
    format_kind: CanonicalFormatKind
    params: dict[str, Any]

    _legacy_format_refs: list[LegacyFormatId] = PrivateAttr(default_factory=list)

    _serialize_canonical = model_serializer(mode="wrap")(_serialize_canonical_model)

    @model_validator(mode="before")
    @classmethod
    def _reject_legacy_conflicts_and_credentials(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        if data.get("canonical_formats_only") is True and data.get("v1_format_ref"):
            raise ValueError(
                "canonical_formats_only=True is mutually exclusive with legacy v1_format_ref"
            )
        for bag_name, bag in (
            ("params", data.get("params")),
            (
                "extras",
                {
                    key: value
                    for key, value in data.items()
                    if key not in cls.model_fields and key != "v1_format_ref"
                },
            ),
        ):
            found = _walk_for_credential_keys(bag, path=bag_name)
            if found is not None:
                raise ValueError(
                    f"{found!r} matches a credential-shaped key suffix and cannot "
                    "be stored in a canonical format declaration"
                )
        return data

    def __init__(self, **data: Any) -> None:
        refs = data.get("v1_format_ref")
        if "capability_id" in data and "format_option_id" not in data:
            data["format_option_id"] = data.pop("capability_id")
        super().__init__(**data)
        if self.__pydantic_extra__ is not None:
            self.__pydantic_extra__.pop("v1_format_ref", None)
        if refs:
            self._legacy_format_refs = [
                LegacyFormatId.model_validate(copy.deepcopy(ref)) for ref in refs
            ]

    @property
    def legacy_format_refs(self) -> tuple[LegacyFormatId, ...]:
        """Original tuples retained only for an explicit compatibility adapter."""

        return tuple(copy.deepcopy(ref) for ref in self._legacy_format_refs)

    def params_as(self, canonical_type: type[_CanonicalParamsT]) -> _CanonicalParamsT:
        """Validate the open parameter bag against a typed canonical model."""

        return canonical_type.model_validate(self.params)

    @model_validator(mode="after")
    def _validate_custom_shape(self) -> Format:
        if self.format_kind is CanonicalFormatKind.custom:
            if not self.format_shape:
                raise ValueError("custom formats require format_shape")
        elif self.format_shape is not None or self.format_schema is not None:
            raise ValueError("format_shape and format_schema are only valid for custom formats")
        return self

Canonical format declaration exposed as Format.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var applies_to_channels : list[adcp.types.generated_poc.enums.channels.MediaChannel] | None

var canonical_formats_only : bool | None

var display_name : str | None

var experimental : bool | None

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind

var format_option_id : str | None

var format_schema : adcp.types.generated_poc.core.platform_extension_ref.PlatformExtensionReference | None

var format_shape : str | None

var model_config

var params : dict[str, typing.Any]

var publisher_domain : str | None

var seller_preference : adcp.types.generated_poc.core.product_format_declaration.SellerPreference | None

Instance variables

prop legacy_format_refs : tuple[LegacyFormatId, ...]

Expand source code

@property
def legacy_format_refs(self) -> tuple[LegacyFormatId, ...]:
    """Original tuples retained only for an explicit compatibility adapter."""

    return tuple(copy.deepcopy(ref) for ref in self._legacy_format_refs)

Original tuples retained only for an explicit compatibility adapter.

Methods

def model_post_init(self: BaseModel, context: Any, /) ‑> None

Expand source code

def init_private_attributes(self: BaseModel, context: Any, /) -> None:
    """This function is meant to behave like a BaseModel method to initialize private attributes.

    It takes context as an argument since that's what pydantic-core passes when calling it.

    Args:
        self: The BaseModel instance.
        context: The context.
    """
    if getattr(self, '__pydantic_private__', None) is None:
        pydantic_private = {}
        for name, private_attr in self.__private_attributes__.items():
            # Avoid needlessly creating a new dict for the validated data:
            if private_attr.default_factory_takes_validated_data:
                default = private_attr.get_default(
                    call_default_factory=True, validated_data={**self.__dict__, **pydantic_private}
                )
            else:
                default = private_attr.get_default(call_default_factory=True)
            if default is not PydanticUndefined:
                pydantic_private[name] = default
        object_setattr(self, '__pydantic_private__', pydantic_private)

This function is meant to behave like a BaseModel method to initialize private attributes.

It takes context as an argument since that's what pydantic-core passes when calling it.

Args

-----=

self

The BaseModel instance.

context

The context.

def params_as(self, canonical_type: type[_CanonicalParamsT]) ‑> ~_CanonicalParamsT

Expand source code

def params_as(self, canonical_type: type[_CanonicalParamsT]) -> _CanonicalParamsT:
    """Validate the open parameter bag against a typed canonical model."""

    return canonical_type.model_validate(self.params)

Validate the open parameter bag against a typed canonical model.

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class GetCreativeDeliveryResponse (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account_id : str | None

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var creatives : Sequence[DeliveryCreative]

var currency : str

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var media_buy_id : str | None

var message : str | None

var model_config

var pagination : adcp.types.generated_poc.creative.get_creative_delivery_response.Pagination | None

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var replayed : bool | None

var reporting_period : adcp.types.generated_poc.creative.get_creative_delivery_response.ReportingPeriod

var status : adcp.types.generated_poc.enums.task_status.TaskStatus

var task_id : str | None

var timestamp : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class GetMediaBuyDeliveryResponse (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var aggregated_totals : adcp.types.generated_poc.media_buy.get_media_buy_delivery_response.AggregatedTotals | None

var attribution_window : adcp.types.generated_poc.core.attribution_window.AttributionWindow | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var currency : str

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var media_buy_deliveries : Sequence[adcp.types.generated_poc.media_buy.get_media_buy_delivery_response.MediaBuyDelivery]

var message : str | None

var model_config

var next_expected_at : pydantic.types.AwareDatetime | None

var notification_type : adcp.types.generated_poc.media_buy.get_media_buy_delivery_response.NotificationType | None

var partial_data : bool | None

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var replayed : bool | None

var reporting_period : adcp.types.generated_poc.media_buy.get_media_buy_delivery_response.ReportingPeriod

var sandbox : bool | None

var sequence_number : int | None

var status : adcp.types.generated_poc.enums.task_status.TaskStatus

var task_id : str | None

var timestamp : pydantic.types.AwareDatetime | None

var unavailable_count : int | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class GetMediaBuysResponse (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var media_buys : Sequence[MediaBuy]

var message : str | None

var model_config

var pagination : adcp.types.generated_poc.core.pagination_response.PaginationResponse | None

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var replayed : bool | None

var sandbox : bool | None

var status : adcp.types.generated_poc.enums.task_status.TaskStatus

var task_id : str | None

var timestamp : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class GetProductsRequest (**data: Any)

Expand source code

class GetProductsRequest(_GetProductsRequestBase):
    """Canonical discovery request with legacy response-field selection rejected."""

    @field_validator("fields")
    @classmethod
    def _reject_legacy_fields(cls, value: Any) -> Any:
        if value and any(
            is_legacy_creative_identity_key(getattr(item, "value", item)) for item in value
        ):
            raise ValueError(
                "format_id and format_ids are unavailable on the canonical get_products API"
            )
        return value

Canonical discovery request with legacy response-field selection rejected.

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

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

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

Ancestors

• adcp.types.canonical_creative._GetProductsRequestBase
• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class GetProductsResponse (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var cache_scope : adcp.types.generated_poc.media_buy.get_products_response.CacheScope | None

var catalog_applied : bool | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var extensions : dict[str, adcp.types.generated_poc.media_buy.get_products_response.Extensions] | None

var filter_diagnostics : adcp.types.generated_poc.media_buy.get_products_response.FilterDiagnostics | None

var governance_context : str | None

var incomplete : list[adcp.types.generated_poc.media_buy.get_products_response.IncompleteItem] | None

var message : str | None

var model_config

var pagination : adcp.types.generated_poc.core.pagination_response.PaginationResponse | None

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

var pricing_version : str | None

var products : list[Product] | None

var property_list_applied : bool | None

var proposals : list[adcp.types.generated_poc.core.proposal.Proposal] | None

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var reason : str | None

var refinement_applied : list[adcp.types.generated_poc.media_buy.get_products_response.RefinementApplied] | None

var replayed : bool | None

var sandbox : bool | None

var status : adcp.types.generated_poc.enums.task_status.TaskStatus

var suggestions : list[adcp.types.generated_poc.media_buy.get_products_response.Suggestion] | None

var targeting_resolution : adcp.types.generated_poc.media_buy.get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None

var task_id : str | None

var timestamp : pydantic.types.AwareDatetime | None

var unchanged : Literal[True] | None

var wholesale_feed_version : str | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class ListCreativesRequest (**data: Any)

Expand source code

class ListCreativesRequest(_ListCreativesRequestBase):
    """Canonical creative read request with legacy field selection rejected."""

    @field_validator("fields")
    @classmethod
    def _reject_legacy_fields(cls, value: Any) -> Any:
        if value and any(
            is_legacy_creative_identity_key(getattr(item, "value", item)) for item in value
        ):
            raise ValueError(
                "format_id and format_ids are unavailable on the canonical list_creatives API"
            )
        return value

Canonical creative read request with legacy field selection rejected.

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

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

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

Ancestors

• adcp.types.canonical_creative._ListCreativesRequestBase
• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class ListCreativesResponse (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var creatives : list[Creative]

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var format_summary : dict[str, int] | None

var governance_context : str | None

var message : str | None

var model_config

var pagination : adcp.types.generated_poc.core.pagination_response.PaginationResponse

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var query_summary : adcp.types.generated_poc.creative.list_creatives_response.QuerySummary

var replayed : bool | None

var sandbox : bool | None

var status : adcp.types.generated_poc.enums.task_status.TaskStatus

var status_summary : adcp.types.generated_poc.creative.list_creatives_response.StatusSummary | None

var task_id : str | None

var timestamp : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class MediaBuy (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var accepted_proposal : adcp.types.generated_poc.media_buy.get_media_buys_response.AcceptedProposal | None

var accepted_proposal_id : str | None

var accepted_proposal_terms_digest : str | None

var account : adcp.types.generated_poc.core.account.Account | None

var available_actions : list[adcp.types.generated_poc.core.canonical_media_buy_action.CanonicalMediaBuyAction | adcp.types.generated_poc.core.media_buy_available_action.MediaBuyAvailableAction] | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var budget_allocation : adcp.types.generated_poc.core.budget_allocation.BudgetAllocation | None

var budget_cap_timezone : str | None

var cancellation : adcp.types.generated_poc.media_buy.get_media_buys_response.Cancellation | None

var confirmed_at : pydantic.types.AwareDatetime | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var created_at : pydantic.types.AwareDatetime | None

var creative_deadline : pydantic.types.AwareDatetime | None

var currency : str

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var health : adcp.types.generated_poc.enums.media_buy_health.MediaBuyHealth | None

var history : list[adcp.types.generated_poc.media_buy.get_media_buys_response.HistoryItem] | None

var impairments : list[adcp.types.generated_poc.core.impairment.Impairment] | None

var indicator_types_evaluated : list[adcp.types.generated_poc.media_buy.get_media_buys_response.IndicatorTypesEvaluatedEnum] | None

var indicators : list[adcp.types.generated_poc.media_buy.get_media_buys_response.Indicator] | None

var indicators_as_of : pydantic.types.AwareDatetime | None

var indicators_evaluated_scope : list[adcp.types.generated_poc.core.indicator_scope.IndicatorScope] | None

var invoice_recipient : adcp.types.generated_poc.core.business_entity.BusinessEntity | None

var media_buy_id : str

var model_config

var name : str | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var packages : Sequence[MediaBuyPackage]

var rejection_reason : str | None

var revision : int

var start_time : pydantic.types.AwareDatetime | None

var status : adcp.types.generated_poc.enums.media_buy_status.MediaBuyStatus

var status_as_of : pydantic.types.AwareDatetime | None

var total_budget : float

var updated_at : pydantic.types.AwareDatetime | None

var valid_actions : list[adcp.types.generated_poc.enums.media_buy_valid_action.MediaBuyValidAction] | None

var webhook_activity : list[adcp.types.generated_poc.core.webhook_activity_record.WebhookActivityRecord] | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class MediaBuyPackage (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var bid_price : float | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var budget : float | None

var canceled : bool | None

var cancellation : adcp.types.generated_poc.media_buy.get_media_buys_response.Cancellation1 | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var creative_approvals : list[adcp.types.generated_poc.media_buy.get_media_buys_response.CreativeApproval] | None

var creative_deadline : pydantic.types.AwareDatetime | None

var currency : str | None

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind | None

var format_option_refs : list[adcp.types.generated_poc.core.format_option_ref.FormatOptionReference] | None

var formats_pending : list[adcp.types.generated_poc.core.product_format_declaration.ProductFormatDeclaration] | None

var formats_to_provide : list[adcp.types.generated_poc.core.product_format_declaration.ProductFormatDeclaration] | None

var impressions : float | None

var indicator_types_evaluated : list[adcp.types.generated_poc.media_buy.get_media_buys_response.IndicatorTypesEvaluatedEnum1] | None

var indicators : list[adcp.types.generated_poc.media_buy.get_media_buys_response.Indicator1] | None

var indicators_as_of : pydantic.types.AwareDatetime | None

var indicators_evaluated_scope : list[adcp.types.generated_poc.core.indicator_scope.IndicatorScope] | None

var min_spend_target : float | None

var model_config

var optimization_goals : list[adcp.types.generated_poc.core.optimization_goal.OptimizationGoal] | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var package_id : str

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

var paused : bool | None

var product_id : str | None

var snapshot : adcp.types.generated_poc.media_buy.get_media_buys_response.Snapshot | None

var snapshot_unavailable_reason : adcp.types.generated_poc.enums.snapshot_unavailable_reason.SnapshotUnavailableReason | None

var start_time : pydantic.types.AwareDatetime | None

var targeting_overlay : adcp.types.generated_poc.core.targeting.TargetingOverlay | None

var targeting_resolution : adcp.types.generated_poc.core.package_targeting_resolution.PackageTargetingResolution | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class Package (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var agency_estimate_number : str | None

var audience_evidence_selections : list[adcp.types.generated_poc.core.audience_evidence_selection.AudienceEvidenceSelection] | None

var bid_price : float | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var budget : float | None

var canceled : bool | None

var cancellation : adcp.types.generated_poc.core.package.Cancellation | None

var catalogs : list[adcp.types.generated_poc.core.catalog.Catalog] | None

var committed_metrics : list[adcp.types.generated_poc.core.committed_metric.CommittedMetric] | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var creative_assignments : list[adcp.types.generated_poc.core.creative_assignment.CreativeAssignment] | None

var creative_deadline : pydantic.types.AwareDatetime | None

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var format_kind : adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind | None

var format_option_refs : list[adcp.types.generated_poc.core.format_option_ref.FormatOptionReference] | None

var formats_pending : list[adcp.types.generated_poc.core.product_format_declaration.ProductFormatDeclaration] | None

var formats_to_provide : list[adcp.types.generated_poc.core.product_format_declaration.ProductFormatDeclaration] | None

var impressions : float | None

var measurement_terms : adcp.types.generated_poc.core.measurement_terms.MeasurementTerms | None

var min_spend_target : float | None

var model_config

var optimization_goals : list[adcp.types.generated_poc.core.optimization_goal.OptimizationGoal] | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var package_id : str

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

var paused : bool | None

var performance_standards : list[adcp.types.generated_poc.core.performance_standard.PerformanceStandard] | None

var price_breakdown : adcp.types.generated_poc.pricing_options.price_breakdown.PriceBreakdown | None

var pricing_option_id : str | None

var product_id : str | None

var start_time : pydantic.types.AwareDatetime | None

var targeting_overlay : adcp.types.generated_poc.core.targeting.TargetingOverlay | None

var targeting_resolution : adcp.types.generated_poc.core.package_targeting_resolution.PackageTargetingResolution | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class PackageRequest (**data: Any)

Expand source code

class PackageRequest(_PackageRequestBase):
    """Canonical package request preserving beta.3 selector constraints."""

    @model_validator(mode="after")
    def _validate_format_params(self) -> PackageRequest:
        if self.params is not None and self.format_kind is None:
            raise ValueError("params requires format_kind")
        if self.params is not None and self.format_kind == "image":
            if ("width" in self.params) != ("height" in self.params):
                raise ValueError("image params width and height must co-occur")
        return self

Canonical package request preserving beta.3 selector constraints.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class PackageUpdate (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var bid_price : float | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var budget : float | None

var canceled : Literal[True] | None

var cancellation_reason : str | None

var catalogs : list[adcp.types.generated_poc.core.catalog.Catalog] | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var creative_assignments : list[adcp.types.generated_poc.core.creative_assignment.CreativeAssignment] | None

var creatives : list[CreativeAsset] | None

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var impressions : float | None

var keyword_targets_add : list[adcp.types.generated_poc.media_buy.package_update.KeywordTargetsAddItem] | None

var keyword_targets_remove : list[adcp.types.generated_poc.media_buy.package_update.KeywordTargetsRemoveItem] | None

var min_spend_target : float | None

var model_config

var negative_keywords_add : list[adcp.types.generated_poc.media_buy.package_update.NegativeKeywordsAddItem] | None

var negative_keywords_remove : list[adcp.types.generated_poc.media_buy.package_update.NegativeKeywordsRemoveItem] | None

var optimization_goals : list[adcp.types.generated_poc.core.optimization_goal.OptimizationGoal] | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var package_id : str

var paused : bool | None

var start_time : pydantic.types.AwareDatetime | None

var targeting_overlay : adcp.types.generated_poc.core.targeting.TargetingOverlay | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class Placement (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var audio_distribution_types : list[adcp.types.generated_poc.enums.audio_distribution_type.AudioDistributionType] | None

var description : str | None

var format_options : list[Format] | None

var kind : adcp.types.generated_poc.core.placement.Kind

var mode : adcp.types.generated_poc.core.placement.Mode

var model_config

var name : str | None

var placement_id : str

var publisher_domain : str | None

var social_placement_surfaces : list[adcp.types.generated_poc.enums.social_placement_surface.SocialPlacementSurface] | None

var sponsored_placement_types : list[adcp.types.generated_poc.enums.sponsored_placement_type.SponsoredPlacementType] | None

var tags : list[str] | None

var video_placement_types : list[adcp.types.generated_poc.enums.video_placement_type.VideoPlacementType] | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class Product (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var allowed_actions : list[adcp.types.generated_poc.core.product_allowed_action.ProductAllowedAction] | None

var audience_evidence : list[adcp.types.generated_poc.core.audience_evidence.AudienceEvidence] | None

var audience_evidence_selections : list[adcp.types.generated_poc.core.audience_evidence_selection.AudienceEvidenceSelection] | None

var audio_distribution_types : list[adcp.types.generated_poc.enums.audio_distribution_type.AudioDistributionType] | None

var brief_relevance : str | None

var cancellation_policy : adcp.types.generated_poc.core.cancellation_policy.CancellationPolicy | None

var catalog_match : adcp.types.generated_poc.core.product.CatalogMatch | None

var catalog_types : list[adcp.types.generated_poc.enums.catalog_type.CatalogType] | None

var channels : list[adcp.types.generated_poc.enums.channels.MediaChannel] | None

var collection_targeting_allowed : bool | None

var collections : list[adcp.types.generated_poc.core.collection_selector.CollectionSelector] | None

var conversion_tracking : adcp.types.generated_poc.core.product.ConversionTracking | None

var creative_policy : adcp.types.generated_poc.core.creative_policy.CreativePolicy | None

var data_provider_signals : list[adcp.types.generated_poc.core.data_provider_signal_selector.DataProviderSignalSelector] | None

var delivery_measurement : adcp.types.generated_poc.core.product.DeliveryMeasurement | None

var delivery_type : adcp.types.generated_poc.enums.delivery_type.DeliveryType

var demographic_targeting : adcp.types.generated_poc.core.demographic_targeting_capability.DemographicTargetingCapability | None

var description : str

var enforced_policies : list[str] | None

var exclusivity : adcp.types.generated_poc.enums.exclusivity.Exclusivity | None

var expires_at : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var forecast : adcp.types.generated_poc.core.delivery_forecast.DeliveryForecast | None

var format_options : list[Format]

var included_signals : list[adcp.types.generated_poc.core.signal_listing.SignalListing] | None

var installments : list[adcp.types.generated_poc.core.installment.Installment] | None

var is_custom : bool | None

var material_submission : adcp.types.generated_poc.core.product.MaterialSubmission | None

var max_optimization_goals : int | None

var measurement_readiness : adcp.types.generated_poc.core.measurement_readiness.MeasurementReadiness | None

var measurement_terms : adcp.types.generated_poc.core.measurement_terms.MeasurementTerms | None

var metric_optimization : adcp.types.generated_poc.core.product.MetricOptimization | None

var model_config

var name : str

var outcome_measurement : adcp.types.generated_poc.core.outcome_measurement.OutcomeMeasurement | None

var overlay_support : adcp.types.generated_poc.core.targeting_overlay_support.TargetingOverlaySupport | None

var performance_standards : list[adcp.types.generated_poc.core.performance_standard.PerformanceStandard] | None

var placements : list[Placement] | None

var pricing_options : list[adcp.types.generated_poc.core.pricing_option.PricingOption]

var product_card : adcp.types.generated_poc.core.product.ProductCard | None

var product_card_detailed : adcp.types.generated_poc.core.product.ProductCardDetailed | None

var product_id : str

var property_targeting_allowed : bool | None

var publisher_properties : list[adcp.types.generated_poc.core.product.PublisherProperty]

var reporting_capabilities : adcp.types.generated_poc.core.reporting_capabilities.ReportingCapabilities

var signal_targeting_allowed : bool | None

var signal_targeting_options : list[adcp.types.generated_poc.core.product_signal_targeting_option.ProductSignalTargetingOption] | None

var signal_targeting_rules : adcp.types.generated_poc.core.signal_targeting_rules.SignalTargetingRules | None

var social_placement_surfaces : list[adcp.types.generated_poc.enums.social_placement_surface.SocialPlacementSurface] | None

var sponsored_placement_types : list[adcp.types.generated_poc.enums.sponsored_placement_type.SponsoredPlacementType] | None

var targeting_resolution : adcp.types.generated_poc.core.product_targeting_resolution.ProductTargetingResolution | None

var trusted_match : adcp.types.generated_poc.core.product.TrustedMatch | None

var vendor_metric_optimization : adcp.types.generated_poc.core.vendor_metric_optimization.VendorMetricOptimization | None

var video_placement_types : list[adcp.types.generated_poc.enums.video_placement_type.VideoPlacementType] | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class ProductFilters (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var audience_evidence_requirements : adcp.types.generated_poc.core.audience_evidence_requirements.AudienceEvidenceRequirements | None

var audio_distribution_types : list[adcp.types.generated_poc.enums.audio_distribution_type.AudioDistributionType] | None

var budget_range : adcp.types.generated_poc.core.product_filters.BudgetRange | None

var channels : list[adcp.types.generated_poc.enums.channels.MediaChannel] | None

var countries : list[adcp.types.generated_poc.core.product_filters.Country] | None

var delivery_type : adcp.types.generated_poc.enums.delivery_type.DeliveryType | None

var end_date : datetime.date | None

var exclusivity : adcp.types.generated_poc.enums.exclusivity.Exclusivity | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var format_kinds : list[adcp.types.generated_poc.core.canonical_format_kind.CanonicalFormatKind] | None

var format_option_refs : list[adcp.types.generated_poc.core.format_option_ref.FormatOptionReference] | None

var geo_proximity : list[adcp.types.generated_poc.core.product_filters.GeoProximityItem] | None

var is_fixed_price : bool | None

var keywords : list[adcp.types.generated_poc.core.product_filters.Keyword] | None

var metros : list[adcp.types.generated_poc.core.product_filters.Metro] | None

var min_exposures : int | None

var model_config

var postal_areas : list[adcp.types.generated_poc.core.postal_area.PostalArea] | None

var pricing_currencies : list[adcp.types.generated_poc.core.product_filters.PricingCurrency] | None

var pricing_structures : list[adcp.types.generated_poc.enums.pricing_structure.PricingStructure] | None

var regions : list[adcp.types.generated_poc.core.product_filters.Region] | None

var required_axe_integrations : list[pydantic.networks.AnyUrl] | None

var required_features : adcp.types.generated_poc.core.media_buy_features.MediaBuyFeatures | None

var required_geo_targeting : list[adcp.types.generated_poc.core.product_filters.RequiredGeoTargetingItem] | None

var required_metrics : list[adcp.types.generated_poc.enums.available_metric.AvailableMetric] | None

var required_performance_standards : list[adcp.types.generated_poc.core.performance_standard.PerformanceStandard] | None

var required_vendor_metrics : list[adcp.types.generated_poc.core.product_filters.RequiredVendorMetric] | None

var signal_targeting : list[adcp.types.generated_poc.core.product_filters.SignalTargetingItem] | None

var social_placement_surfaces : list[adcp.types.generated_poc.enums.social_placement_surface.SocialPlacementSurface] | None

var sponsored_placement_types : list[adcp.types.generated_poc.enums.sponsored_placement_type.SponsoredPlacementType] | None

var standard_formats_only : bool | None

var start_date : datetime.date | None

var trusted_match : adcp.types.generated_poc.core.product_filters.TrustedMatch | None

var video_placement_types : list[adcp.types.generated_poc.enums.video_placement_type.VideoPlacementType] | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class SyncCreativesRequest (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.generated_poc.core.account_ref.AccountReference

var adcp_major_version : int | None

var adcp_version : str | None

var assignment_operations : list[adcp.types.generated_poc.creative.sync_creatives_request.AssignmentOperations] | None

var assignments : list[adcp.types.generated_poc.creative.sync_creatives_request.Assignment] | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var creative_ids : list[str] | None

var creatives : list[CreativeAsset]

var delete_missing : bool | None

var dry_run : bool | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var idempotency_key : str

var model_config

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var validation_mode : adcp.types.generated_poc.enums.validation_mode.ValidationMode | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class UpdateMediaBuyRequest (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : adcp.types.generated_poc.core.account_ref.AccountReference

var adcp_major_version : int | None

var adcp_version : str | None

var bidding : adcp.types.generated_poc.core.bidding_policy.BiddingPolicy | None

var budget_allocation : adcp.types.generated_poc.core.budget_allocation.BudgetAllocation | None

var budget_cap_timezone : str | None

var canceled : Literal[True] | None

var cancellation_reason : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var daily_budget_cap : float | None

var end_time : pydantic.types.AwareDatetime | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var idempotency_key : str

var invoice_recipient : adcp.types.generated_poc.core.business_entity.BusinessEntity | None

var media_buy_id : str

var model_config

var name : str | None

var new_packages : list[PackageRequest] | None

var pacing : adcp.types.generated_poc.enums.pacing.Pacing | None

var packages : list[PackageUpdate] | None

var paused : bool | None

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var reporting_webhook : adcp.types.generated_poc.core.reporting_webhook.ReportingWebhook | None

var revision : int | None

var start_time : adcp.types.generated_poc.core.start_timing.StartTiming | None

var total_budget : adcp.types.generated_poc.media_buy.update_media_buy_request.TotalBudget | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class UpdateMediaBuyResponse1 (**data: Any)

Expand source code

class UpdateMediaBuyResponse1(_UpdateMediaBuyResponse1Base):
    """Canonical update response preserving the 3.x legacy-status normalizer."""

    @model_validator(mode="before")
    @classmethod
    def _normalize_legacy_status(cls, data: Any) -> Any:
        if not isinstance(data, dict):
            return data
        raw_status = unwrap_enum_value(data.get("status"))
        media_buy_status = unwrap_enum_value(data.get("media_buy_status"))
        if raw_status is None or raw_status == "completed":
            return {**data, "status": "completed"}
        if media_buy_status is None and raw_status in MEDIA_BUY_LEGACY_STATUS_VALUES:
            return {**data, "media_buy_status": raw_status, "status": "completed"}
        if media_buy_status is not None and raw_status == media_buy_status:
            return {**data, "status": "completed"}
        return data

Canonical update response preserving the 3.x legacy-status normalizer.

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

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

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

Ancestors

• adcp.types.canonical_creative._UpdateMediaBuyResponse1Base
• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class UpdateMediaBuyResponse2 (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var errors : list[adcp.types.generated_poc.core.error.Error]

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var model_config

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary

class UpdateMediaBuyResponse3 (**data: Any)

Base class enforcing the primary canonical runtime boundary.

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

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

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

Ancestors

• CanonicalBoundaryModel
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_error : adcp.types.generated_poc.core.error.Error | None

var adcp_major_version : int | None

var adcp_version : str | None

var context : adcp.types.generated_poc.core.context.ContextObject | None

var context_id : str | None

var errors : list[adcp.types.generated_poc.core.error.Error] | None

var ext : adcp.types.generated_poc.core.ext.ExtensionObject | None

var governance_context : str | None

var message : str | None

var model_config

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

var push_notification_config : adcp.types.generated_poc.core.push_notification_config.PushNotificationConfig | None

var replayed : bool | None

var status : Literal[]

var task_id : str

var timestamp : pydantic.types.AwareDatetime | None

Inherited members

• CanonicalBoundaryModel:
  • model_dump
  • model_dump_json
  • model_json_schema
  • model_summary