Module adcp.types.domains.property

Types the AdCP property schemas declare.

Importing from the domain says which variant you mean, where the flat adcp.types namespace can only bind one class per name:

from adcp.types.domains.property import <Type>

A type this domain declares in more than one schema is not here: import it from its own schema's module, adcp.types.domains.property.<schema>. Nothing here is renamed.

Auto-generated from the generated domain tree. DO NOT EDIT MANUALLY. Generation date: 2026-10-04 18:45:11 UTC

Sub-modules

adcp.types.domains.property.authorization_result

adcp.types.domains.property.base_property_source

adcp.types.domains.property.create_property_list_request

adcp.types.domains.property.create_property_list_response

adcp.types.domains.property.delete_property_list_request

adcp.types.domains.property.delete_property_list_response

adcp.types.domains.property.delivery_record

adcp.types.domains.property.get_property_list_request

adcp.types.domains.property.get_property_list_response

adcp.types.domains.property.list_property_lists_request

adcp.types.domains.property.list_property_lists_response

adcp.types.domains.property.property_error

adcp.types.domains.property.property_feature

adcp.types.domains.property.property_feature_definition

adcp.types.domains.property.property_feature_result

adcp.types.domains.property.property_feature_value

adcp.types.domains.property.property_list

adcp.types.domains.property.property_list_changed_webhook

adcp.types.domains.property.property_list_filters

adcp.types.domains.property.update_property_list_request

adcp.types.domains.property.update_property_list_response

adcp.types.domains.property.validate_property_delivery_request

adcp.types.domains.property.validate_property_delivery_response

adcp.types.domains.property.validation_result

Classes

class Aggregate (**data: Any)

Expand source code

class Aggregate(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    score: Annotated[
        StrictFloat | None,
        Field(description='Numeric score (0-100 scale typical, but agent-defined)'),
    ] = None
    grade: Annotated[
        str | None,
        Field(description="Letter grade or category (e.g., 'A+', 'B-', 'Gold', 'Compliant')"),
    ] = None
    label: Annotated[
        str | None,
        Field(description="Human-readable summary (e.g., '85% compliant', 'High quality')"),
    ] = None
    methodology_url: Annotated[
        AnyUrl | None, Field(description='URL explaining how this aggregate was calculated')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var grade : str | None

var label : str | None

var methodology_url : pydantic.networks.AnyUrl | None

var model_config

var score : float | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizationResult (**data: Any)

Expand source code

class AuthorizationResult(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    status: Annotated[
        Status,
        Field(
            description='Authorization status: authorized (agent in adagents.json), unauthorized (agent not in adagents.json), unknown (could not fetch or parse adagents.json)'
        ),
    ]
    publisher_domain: Annotated[
        str | None, Field(description='The publisher domain where adagents.json was checked')
    ] = None
    sales_agent_url: Annotated[
        AnyUrl | None, Field(description='The sales agent URL that was validated')
    ] = None
    violation: Annotated[
        Violation | None,
        Field(
            description='Details about the authorization failure (only present for unauthorized status)'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var model_config

var publisher_domain : str | None

var sales_agent_url : pydantic.networks.AnyUrl | None

var status : Status

var violation : Violation | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AuthorizationSummary (**data: Any)

Expand source code

class AuthorizationSummary(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    records_checked: Annotated[
        SchemaInt, Field(description='Number of records with sales_agent_url provided')
    ]
    impressions_checked: Annotated[
        SchemaInt, Field(description='Total impressions from records with sales_agent_url')
    ]
    authorized_records: Annotated[
        SchemaInt, Field(description='Number of records where sales agent was authorized')
    ]
    authorized_impressions: Annotated[
        SchemaInt, Field(description='Impressions from authorized records')
    ]
    unauthorized_records: Annotated[
        SchemaInt, Field(description='Number of records where sales agent was NOT authorized')
    ]
    unauthorized_impressions: Annotated[
        SchemaInt, Field(description='Impressions from unauthorized records')
    ]
    unknown_records: Annotated[
        SchemaInt,
        Field(
            description='Number of records where authorization could not be determined (adagents.json unavailable)'
        ),
    ]
    unknown_impressions: Annotated[
        SchemaInt,
        Field(description='Impressions from records where authorization could not be determined'),
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var authorized_impressions : int

var authorized_records : int

var impressions_checked : int

var model_config

var records_checked : int

var unauthorized_impressions : int

var unauthorized_records : int

var unknown_impressions : int

var unknown_records : int

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class BasePropertySource1 (**data: Any)

Expand source code

class BasePropertySource1(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    selection_type: Annotated[
        Literal['publisher_tags'],
        Field(description='Discriminator indicating selection by property tags within a publisher'),
    ] = 'publisher_tags'
    publisher_domain: Annotated[
        str,
        Field(
            description="Domain where publisher's adagents.json is hosted (e.g., 'raptive.com')",
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ]
    tags: Annotated[
        list[property_tag.PropertyTag],
        Field(
            description="Property tags from the publisher's adagents.json. Selects all properties with these tags.",
            min_length=1,
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var model_config

var publisher_domain : str

var selection_type : Literal['publisher_tags']

var tags : list[PropertyTag]

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class BasePropertySource2 (**data: Any)

Expand source code

class BasePropertySource2(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    selection_type: Annotated[
        Literal['publisher_ids'],
        Field(
            description='Discriminator indicating selection by specific property IDs within a publisher'
        ),
    ] = 'publisher_ids'
    publisher_domain: Annotated[
        str,
        Field(
            description="Domain where publisher's adagents.json is hosted (e.g., 'raptive.com')",
            pattern='^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$',
        ),
    ]
    property_ids: Annotated[
        list[property_id.PropertyId],
        Field(description="Specific property IDs from the publisher's adagents.json", min_length=1),
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var model_config

var property_ids : list[PropertyId]

var publisher_domain : str

var selection_type : Literal['publisher_ids']

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class BasePropertySource3 (**data: Any)

Expand source code

class BasePropertySource3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    selection_type: Annotated[
        Literal['identifiers'],
        Field(description='Discriminator indicating selection by direct identifiers'),
    ] = 'identifiers'
    identifiers: Annotated[
        list[identifier.Identifier],
        Field(description='Direct property identifiers (domains, app IDs, etc.)', min_length=1),
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var identifiers : list[Identifier]

var model_config

var selection_type : Literal['identifiers']

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class ChangeSummary (**data: Any)

Expand source code

class ChangeSummary(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    properties_added: Annotated[
        SchemaInt | None, Field(description='Number of properties added since last resolution')
    ] = None
    properties_removed: Annotated[
        SchemaInt | None, Field(description='Number of properties removed since last resolution')
    ] = None
    total_properties: Annotated[
        SchemaInt | None, Field(description='Total properties in the resolved list')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var model_config

var properties_added : int | None

var properties_removed : int | None

var total_properties : int | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Code (*args, **kwds)

Expand source code

class Code(StrEnum):
    PROPERTY_NOT_FOUND = 'PROPERTY_NOT_FOUND'
    PROPERTY_NOT_MONITORED = 'PROPERTY_NOT_MONITORED'
    LIST_NOT_FOUND = 'LIST_NOT_FOUND'
    LIST_ACCESS_DENIED = 'LIST_ACCESS_DENIED'
    METHODOLOGY_NOT_SUPPORTED = 'METHODOLOGY_NOT_SUPPORTED'
    JURISDICTION_NOT_SUPPORTED = 'JURISDICTION_NOT_SUPPORTED'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var JURISDICTION_NOT_SUPPORTED

var LIST_ACCESS_DENIED

var LIST_NOT_FOUND

var METHODOLOGY_NOT_SUPPORTED

var PROPERTY_NOT_FOUND

var PROPERTY_NOT_MONITORED

class CountriesAllItem (value: Any = <object object>, *, root: Any = <object object>)

Expand source code

class CountriesAllItem(ScalarStr):
    __slots__ = ()
    _constraints = {'pattern': '^[A-Z]{2}$'}

A str generated from a JSON Schema string root.

Ancestors

• adcp.types._scalar.ScalarStr
• adcp.types._scalar._ScalarRoot
• builtins.str

class Coverage (**data: Any)

Expand source code

class Coverage(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    property_types: Annotated[
        list[str] | None, Field(description='Property types this feature applies to')
    ] = None
    countries: Annotated[
        list[str] | None, Field(description='Countries where this feature is available')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var countries : list[str] | None

var model_config

var property_types : list[str] | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class CoverageStatus (*args, **kwds)

Expand source code

class CoverageStatus(StrEnum):
    covered = 'covered'
    not_covered = 'not_covered'
    pending = 'pending'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var covered

var not_covered

var pending

class CreatePropertyListRequest (**data: Any)

Expand source code

class CreatePropertyListRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that will own the list. Pass a natural key (brand, operator, optional sandbox) or a seller-assigned account_id from list_accounts. When omitted, this task applies its task-local single-account shortcut: if exactly one account is accessible to the authenticated caller, the seller may assign the list to that account; otherwise it MUST return an account-required or ambiguous-account error. Omission MUST NOT mean an undocumented credential-local default account.'
        ),
    ] = None
    name: Annotated[str, Field(description='Human-readable name for the list')]
    description: Annotated[str | None, Field(description="Description of the list's purpose")] = (
        None
    )
    base_properties: Annotated[
        list[base_property_source.BasePropertySource] | None,
        Field(
            description="Array of property sources to evaluate. Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers). If omitted, queries the agent's entire property database.",
            min_length=1,
        ),
    ] = None
    filters: Annotated[
        property_list_filters.PropertyListFilters | None,
        Field(description='Dynamic filters to apply when resolving the list'),
    ] = None
    brand: Annotated[
        brand_ref.BrandReference | None,
        Field(
            description='Brand reference. When provided, the agent automatically applies appropriate rules based on brand characteristics (industry, target_audience, etc.). Resolved at execution time.'
        ),
    ] = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated unique key for this request. Prevents duplicate property list creation on retries. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the 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

• AdcpRequest
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var base_properties : list[BasePropertySource1 | BasePropertySource2 | BasePropertySource3] | None

var brand : BrandReference | None

var context : ContextObject | None

var description : str | None

var ext : ExtensionObject | None

var filters : PropertyListFilters | None

var idempotency_key : str

var model_config

var name : str

Inherited members

• AdcpRequest:
  • get_account
  • get_adcp_major_version
  • get_adcp_version
  • get_context
  • get_idempotency_key
  • get_push_notification_config
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class CreatePropertyListResponse (**data: Any)

Expand source code

class CreatePropertyListResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list: Annotated[property_list.PropertyList, Field(description='The created property list')]
    auth_token: Annotated[
        str,
        Field(
            description='Token that can be shared with sellers to authorize fetching this list. Store this - it is only returned at creation time.'
        ),
    ]
    replayed: Annotated[
        StrictBool | None,
        Field(
            description="Set to true when this response was returned from the idempotency cache rather than from a fresh execution. Set to false (or omitted) when the request was executed fresh. Buyers use this to distinguish cached replays from new executions — matters for billing reconciliation, audit logs, state-machine routing (cached state-tracking fields are historical snapshots, not current state — re-read via the resource's read endpoint), and any downstream system that assumes exactly-once event semantics. `replayed` appears only when the request actually resolved through the idempotency cache. Pure reads may ignore an optional `idempotency_key`; when a seller voluntarily caches keyed reads, those responses use the same replay indicator and full cache contract."
        ),
    ] = False
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

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

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

Ancestors

• AdcpResponse
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var auth_token : str

var context : ContextObject | None

var ext : ExtensionObject | None

var list : PropertyList

var model_config

var replayed : bool | None

Inherited members

• AdcpResponse:
  • get_adcp_error
  • get_context
  • get_message
  • get_replayed
  • get_status
  • get_task_id
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class DeletePropertyListRequest (**data: Any)

Expand source code

class DeletePropertyListRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list_id: Annotated[str, Field(description='ID of the property list to delete')]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that owns the list. Required when the authenticated agent has access to multiple accounts; optional otherwise.'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the 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

• AdcpRequest
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var context : ContextObject | None

var ext : ExtensionObject | None

var idempotency_key : str

var list_id : str

var model_config

Inherited members

• AdcpRequest:
  • get_account
  • get_adcp_major_version
  • get_adcp_version
  • get_context
  • get_idempotency_key
  • get_push_notification_config
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class DeletePropertyListResponse (**data: Any)

Expand source code

class DeletePropertyListResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    deleted: Annotated[StrictBool, Field(description='Whether the list was successfully deleted')]
    list_id: Annotated[str, Field(description='ID of the deleted list')]
    replayed: Annotated[
        StrictBool | None,
        Field(
            description="Set to true when this response was returned from the idempotency cache rather than from a fresh execution. Set to false (or omitted) when the request was executed fresh. Buyers use this to distinguish cached replays from new executions — matters for billing reconciliation, audit logs, state-machine routing (cached state-tracking fields are historical snapshots, not current state — re-read via the resource's read endpoint), and any downstream system that assumes exactly-once event semantics. `replayed` appears only when the request actually resolved through the idempotency cache. Pure reads may ignore an optional `idempotency_key`; when a seller voluntarily caches keyed reads, those responses use the same replay indicator and full cache contract."
        ),
    ] = False
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

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

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

Ancestors

• AdcpResponse
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var context : ContextObject | None

var deleted : bool

var ext : ExtensionObject | None

var list_id : str

var model_config

var replayed : bool | None

Inherited members

• AdcpResponse:
  • get_adcp_error
  • get_context
  • get_message
  • get_replayed
  • get_status
  • get_task_id
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class DeliveryRecord (**data: Any)

Expand source code

class DeliveryRecord(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    identifier: Annotated[
        identifier_1.Identifier,
        Field(description='The property identifier where impressions were delivered'),
    ]
    impressions: Annotated[
        SchemaInt, Field(description='Number of impressions delivered to this identifier', ge=0)
    ]
    record_id: Annotated[
        str | None,
        Field(
            description='Optional client-provided ID for correlating results back to source data'
        ),
    ] = None
    sales_agent_url: Annotated[
        AnyUrl | None,
        Field(
            description="URL of the sales agent that sold this inventory. If provided, authorization is validated against the property's adagents.json."
        ),
    ] = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var ext : ExtensionObject | None

var identifier : Identifier

var impressions : int

var model_config

var record_id : str | None

var sales_agent_url : pydantic.networks.AnyUrl | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Feature (**data: Any)

Expand source code

class Feature(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    feature_id: Annotated[
        str,
        Field(
            description="Which feature was evaluated. Data features come from the governance agent's feature catalog (e.g., 'mfa_score', 'carbon_score'). Record-level structural checks use reserved namespaces: 'record:list_membership', 'record:excluded', 'delivery:seller_authorization', 'delivery:click_url_presence'. Reserved prefixes: 'record:', 'delivery:'."
        ),
    ]
    status: feature_check_status.FeatureCheckStatus
    policy_id: Annotated[
        str | None,
        Field(
            description='Optional attribution — when this feature was evaluated for the purpose of a specific policy, policy_id references the authorizing PolicyEntry. Property-list agents populate when the validation was motivated by a specific policy. See /docs/governance/policy-attribution.'
        ),
    ] = None
    explanation: Annotated[
        str | None, Field(description='Directional human-readable explanation of the result.')
    ] = None
    requirement: Annotated[
        Requirement | None,
        Field(
            description='The feature requirement that was not met. MAY be present on failed features when the caller authored the requirement (e.g., feature_requirements on a property list). The buyer set these thresholds — echoing them back enables fix-and-retry loops without looking up the list definition.'
        ),
    ] = None
    confidence: Annotated[
        StrictFloat | None,
        Field(
            description='Optional evaluator confidence in this result (0-1). Distinguishes certain verdicts from ambiguous ones.',
            ge=0.0,
            le=1.0,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var confidence : float | None

var explanation : str | None

var feature_id : str

var model_config

var policy_id : str | None

var requirement : Requirement | None

var status : FeatureCheckStatus

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class GetPropertyListRequest (**data: Any)

Expand source code

class GetPropertyListRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list_id: Annotated[str, Field(description='ID of the property list to retrieve')]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that owns the list. Required when the authenticated agent has access to multiple accounts and the list_id is not globally unique within that scope; optional otherwise.'
        ),
    ] = None
    resolve: Annotated[
        StrictBool | None,
        Field(
            description='Whether to apply filters and return resolved identifiers (default: true)'
        ),
    ] = True
    pagination: Annotated[
        Pagination | None,
        Field(
            description='Pagination parameters. Uses higher limits than standard pagination because property lists can contain tens of thousands of identifiers.'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the 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

• AdcpRequest
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var context : ContextObject | None

var ext : ExtensionObject | None

var list_id : str

var model_config

var pagination : Pagination | None

var resolve : bool | None

Inherited members

• AdcpRequest:
  • get_account
  • get_adcp_major_version
  • get_adcp_version
  • get_context
  • get_idempotency_key
  • get_push_notification_config
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class GetPropertyListResponse (**data: Any)

Expand source code

class GetPropertyListResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list: Annotated[
        property_list.PropertyList,
        Field(description='The property list metadata (always returned)'),
    ]
    identifiers: Annotated[
        _list[identifier.Identifier] | None,
        Field(
            description='Resolved identifiers that passed filters (if resolve=true). Cache these locally for real-time use.'
        ),
    ] = None
    pagination: pagination_response.PaginationResponse | None = None
    resolved_at: Annotated[
        AwareDatetime | None, Field(description='When the list was resolved')
    ] = None
    cache_valid_until: Annotated[
        AwareDatetime | None,
        Field(
            description='Cache expiration timestamp. Re-fetch the list after this time to get updated identifiers.'
        ),
    ] = None
    coverage_gaps: Annotated[
        dict[str, _list[identifier.Identifier]] | None,
        Field(
            description="Properties included in the list despite missing feature data. Only present when a feature_requirement has if_not_covered='include'. Maps feature_id to list of identifiers not covered for that feature."
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

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

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

Ancestors

• AdcpResponse
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var cache_valid_until : pydantic.types.AwareDatetime | None

var context : ContextObject | None

var coverage_gaps : dict[str, list[Identifier]] | None

var ext : ExtensionObject | None

var identifiers : list[Identifier] | None

var list : PropertyList

var model_config

var pagination : PaginationResponse | None

var resolved_at : pydantic.types.AwareDatetime | None

Inherited members

• AdcpResponse:
  • get_adcp_error
  • get_context
  • get_message
  • get_replayed
  • get_status
  • get_task_id
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class ListPropertyListsRequest (**data: Any)

Expand source code

class ListPropertyListsRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Filter to lists owned by this account. When omitted, returns lists across all accounts accessible to the authenticated agent.'
        ),
    ] = None
    name_contains: Annotated[
        str | None, Field(description='Filter to lists whose name contains this string')
    ] = None
    pagination: pagination_request.PaginationRequest | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the 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

• AdcpRequest
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var context : ContextObject | None

var ext : ExtensionObject | None

var model_config

var name_contains : str | None

var pagination : PaginationRequest | None

Inherited members

• AdcpRequest:
  • get_account
  • get_adcp_major_version
  • get_adcp_version
  • get_context
  • get_idempotency_key
  • get_push_notification_config
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class ListPropertyListsResponse (**data: Any)

Expand source code

class ListPropertyListsResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    lists: Annotated[
        list[property_list.PropertyList],
        Field(description='Array of property lists (metadata only, not resolved properties)'),
    ]
    pagination: pagination_response.PaginationResponse | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

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

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

Ancestors

• AdcpResponse
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var context : ContextObject | None

var ext : ExtensionObject | None

var lists : list[PropertyList]

var model_config

var pagination : PaginationResponse | None

Inherited members

• AdcpResponse:
  • get_adcp_error
  • get_context
  • get_message
  • get_replayed
  • get_status
  • get_task_id
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class Pagination (**data: Any)

Expand source code

class Pagination(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    max_results: Annotated[
        SchemaInt | None,
        Field(description='Maximum number of identifiers to return per page', ge=1, le=10000),
    ] = 1000
    cursor: Annotated[
        str | None,
        Field(description='Opaque cursor from a previous response to fetch the next page'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var cursor : str | None

var max_results : int | None

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyError (**data: Any)

Expand source code

class PropertyError(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    code: Annotated[Code, Field(description='Error code')]
    property: Annotated[
        property_1.Property | None, Field(description='The property that caused the error')
    ] = None
    message: Annotated[str, Field(description='Human-readable error message')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var code : Code

var message : str

var model_config

var property : Property | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyFeature (**data: Any)

Expand source code

class PropertyFeature(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    feature_id: Annotated[str, Field(description='Identifier for the feature being assessed')]
    value: Annotated[str, Field(description='The feature value')]
    source: Annotated[
        str | None,
        Field(description='Source of the feature data (e.g., app_store_privacy_label, tcf_string)'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var feature_id : str

var model_config

var source : str | None

var value : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyFeatureDefinition (**data: Any)

Expand source code

class PropertyFeatureDefinition(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    feature_id: Annotated[
        str,
        Field(
            description="Unique identifier for this feature (e.g., 'consent_quality', 'carbon_score'). Features prefixed with 'registry:' reference standardized policies from the shared policy registry (e.g., 'registry:us_coppa', 'registry:uk_hfss'). Unprefixed feature IDs are agent-defined."
        ),
    ]
    name: Annotated[str, Field(description='Human-readable name for the feature')]
    description: Annotated[
        str | None, Field(description='Description of what this feature measures or represents')
    ] = None
    type: Annotated[
        Type,
        Field(
            description='The type of values this feature produces: binary (true/false), quantitative (numeric range), categorical (enumerated values)'
        ),
    ]
    range: Annotated[
        Range | None, Field(description='For quantitative features, the valid range of values')
    ] = None
    allowed_values: Annotated[
        list[str] | None, Field(description='For categorical features, the set of valid values')
    ] = None
    coverage: Annotated[
        Coverage | None, Field(description='What this feature covers (empty arrays = all)')
    ] = None
    methodology_url: Annotated[
        AnyUrl,
        Field(
            description='URL to documentation explaining how this feature is calculated/measured'
        ),
    ]
    methodology_version: Annotated[
        str | None, Field(description='Version identifier for the methodology (for audit trails)')
    ] = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var allowed_values : list[str] | None

var coverage : Coverage | None

var description : str | None

var ext : ExtensionObject | None

var feature_id : str

var methodology_url : pydantic.networks.AnyUrl

var methodology_version : str | None

var model_config

var name : str

var range : Range | None

var type : Type

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyFeatureResult (**data: Any)

Expand source code

class PropertyFeatureResult(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    property: Annotated[
        str | property_id.PropertyId, Field(description='The property these features apply to')
    ]
    features: Annotated[
        dict[str, property_feature_value.PropertyFeatureValue] | None,
        Field(description='Map of feature_id to feature value'),
    ] = None
    coverage_status: Annotated[
        CoverageStatus,
        Field(
            description='Whether this property is covered by this governance agent: covered (has data), not_covered (not measured), pending (measurement in progress)'
        ),
    ]
    last_evaluated: Annotated[
        AwareDatetime | None,
        Field(description='When features were last evaluated for this property'),
    ] = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var coverage_status : CoverageStatus

var ext : ExtensionObject | None

var features : dict[str, PropertyFeatureValue] | None

var last_evaluated : pydantic.types.AwareDatetime | None

var model_config

var property : str | PropertyId

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyFeatureValue (**data: Any)

Expand source code

class PropertyFeatureValue(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    value: Annotated[
        StrictBool | StrictFloat | str,
        Field(
            description='The feature value. Type depends on feature definition: boolean for binary, number for quantitative, string for categorical.'
        ),
    ]
    unit: Annotated[
        str | None,
        Field(
            description="Unit of measurement for quantitative values (e.g., 'gCO2e/1000_impressions', 'percentage')"
        ),
    ] = None
    confidence: Annotated[
        StrictFloat | None,
        Field(description='Confidence score for this value (0-1)', ge=0.0, le=1.0),
    ] = None
    measured_at: Annotated[
        AwareDatetime | None, Field(description='When this specific value was measured')
    ] = None
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            description='When this certification/value expires (for time-limited certifications)'
        ),
    ] = None
    methodology_version: Annotated[
        str | None, Field(description='Version of the methodology used to calculate this value')
    ] = None
    details: Annotated[
        dict[str, Any] | None,
        Field(description='Additional vendor-specific details about this measurement'),
    ] = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var confidence : float | None

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

var expires_at : pydantic.types.AwareDatetime | None

var ext : ExtensionObject | None

var measured_at : pydantic.types.AwareDatetime | None

var methodology_version : str | None

var model_config

var unit : str | None

var value : bool | float | str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyList (**data: Any)

Expand source code

class PropertyList(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    list_id: Annotated[str, Field(description='Unique identifier for this property list')]
    name: Annotated[str, Field(description='Human-readable name for the list')]
    description: Annotated[str | None, Field(description="Description of the list's purpose")] = (
        None
    )
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that owns this list. Returned as account_id form (seller-assigned identifier).'
        ),
    ] = None
    base_properties: Annotated[
        list[base_property_source.BasePropertySource] | None,
        Field(
            description="Array of property sources to evaluate. Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers). If omitted, queries the agent's entire property database."
        ),
    ] = None
    filters: Annotated[
        property_list_filters.PropertyListFilters | None,
        Field(description='Dynamic filters applied when resolving the list'),
    ] = None
    brand: Annotated[
        brand_ref.BrandReference | None,
        Field(
            description='Brand reference used to automatically apply appropriate rules. Resolved to full brand identity at execution time.'
        ),
    ] = None
    webhook_url: Annotated[
        AnyUrl | None,
        Field(description='URL to receive notifications when the resolved list changes'),
    ] = None
    cache_duration_hours: Annotated[
        SchemaInt | None,
        Field(
            description='Recommended cache duration for resolved list. Consumers should re-fetch after this period.',
            ge=1,
        ),
    ] = 24
    created_at: Annotated[AwareDatetime | None, Field(description='When the list was created')] = (
        None
    )
    updated_at: Annotated[
        AwareDatetime | None, Field(description='When the list was last modified')
    ] = None
    property_count: Annotated[
        SchemaInt | None,
        Field(description='Number of properties in the resolved list (at time of last resolution)'),
    ] = None
    pricing_options: Annotated[
        list[vendor_pricing_option.VendorPricingOption] | None,
        Field(
            description='Pricing options for this property list. Present when the requesting account has a billing relationship with the list provider. The buyer passes the selected pricing_option_id in report_usage.',
            min_length=1,
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var account : AccountReference1 | AccountReference2 | None

var base_properties : list[BasePropertySource1 | BasePropertySource2 | BasePropertySource3] | None

var brand : BrandReference | None

var cache_duration_hours : int | None

var created_at : pydantic.types.AwareDatetime | None

var description : str | None

var filters : PropertyListFilters | None

var list_id : str

var model_config

var name : str

var pricing_options : list[VendorPricingOption7 | VendorPricingOption8 | VendorPricingOption9 | VendorPricingOption10 | VendorPricingOption11] | None

var property_count : int | None

var updated_at : pydantic.types.AwareDatetime | None

var webhook_url : pydantic.networks.AnyUrl | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyListChangedWebhook (**data: Any)

Expand source code

class PropertyListChangedWebhook(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    idempotency_key: Annotated[
        str,
        Field(
            description='Sender-generated key stable across retries of the same webhook event. Governance agents MUST generate a cryptographically random value (UUID v4 recommended) per distinct list-change event and reuse the same key on every retry. Recipients MUST dedupe by this key, scoped to the authenticated sender identity established by the RFC 9421 signing key — keys from different governance agents are independent.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]
    event: Annotated[Literal['property_list_changed'], Field(description='The event type')] = 'property_list_changed'
    list_id: Annotated[str, Field(description='ID of the property list that changed')]
    list_name: Annotated[str | None, Field(description='Name of the property list')] = None
    change_summary: Annotated[
        ChangeSummary | None, Field(description='Summary of changes to the resolved list')
    ] = None
    resolved_at: Annotated[AwareDatetime, Field(description='When the list was re-resolved')]
    cache_valid_until: Annotated[
        AwareDatetime | None,
        Field(description='When the consumer should refresh from the governance agent'),
    ] = None
    signature: Annotated[
        str,
        Field(
            deprecated=True,
            description='Deprecated 3.x compatibility marker. Property-list webhooks previously required this field but did not define an implementable signature algorithm, signed bytes, or key-discovery contract. RFC 9421 signatures are carried in the Signature and Signature-Input HTTP headers and bind the complete payload through Content-Digest. New 3.2 senders MUST set this field to the literal value `rfc9421`; receivers MUST accept any string from an older 3.x sender and MUST ignore it when authenticating a delivery. The field remains required through 3.x for schema compatibility and is removed in 4.0.',
        ),
    ]
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var cache_valid_until : pydantic.types.AwareDatetime | None

var change_summary : ChangeSummary | None

var event : Literal['property_list_changed']

var ext : ExtensionObject | None

var idempotency_key : str

var list_id : str

var list_name : str | None

var model_config

var resolved_at : pydantic.types.AwareDatetime

var signature : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class PropertyListFilters (**data: Any)

Expand source code

class PropertyListFilters(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    countries_all: Annotated[
        list[CountriesAllItem] | None,
        Field(
            description='Property must have feature data for ALL listed countries (ISO codes). When omitted, no country restriction is applied.',
            min_length=1,
        ),
    ] = None
    channels_any: Annotated[
        list[channels.MediaChannel] | None,
        Field(
            description='Property must support ANY of the listed channels. When omitted, no channel restriction is applied.',
            min_length=1,
        ),
    ] = None
    property_types: Annotated[
        list[property_type.PropertyType] | None,
        Field(description='Filter to these property types', min_length=1),
    ] = None
    feature_requirements: Annotated[
        list[feature_requirement.FeatureRequirement] | None,
        Field(
            description='Feature-based requirements. Property must pass ALL requirements (AND logic).',
            min_length=1,
        ),
    ] = None
    exclude_identifiers: Annotated[
        list[identifier.Identifier] | None,
        Field(description='Identifiers to always exclude from results', min_length=1),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var channels_any : list[MediaChannel] | None

var countries_all : list[CountriesAllItem] | None

var exclude_identifiers : list[Identifier] | None

var feature_requirements : list[FeatureRequirement] | None

var model_config

var property_types : list[PropertyType] | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Range (**data: Any)

Expand source code

class Range(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min: Annotated[StrictFloat, Field(description='Minimum value')]
    max: Annotated[StrictFloat, Field(description='Maximum value')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var max : float

var min : float

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Requirement (**data: Any)

Expand source code

class Requirement(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min_value: Annotated[
        StrictFloat | None, Field(description='Minimum value that was required')
    ] = None
    max_value: Annotated[
        StrictFloat | None, Field(description='Maximum value that was allowed')
    ] = None
    allowed_values: Annotated[
        list[Any] | None, Field(description='Values that would have been acceptable')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var allowed_values : list[typing.Any] | None

var max_value : float | None

var min_value : float | None

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Summary (**data: Any)

Expand source code

class Summary(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    total_records: Annotated[SchemaInt, Field(description='Total number of records validated')]
    total_impressions: Annotated[
        SchemaInt, Field(description='Total impressions across all records')
    ]
    compliant_records: Annotated[
        SchemaInt, Field(description='Number of records with compliant status')
    ]
    compliant_impressions: Annotated[
        SchemaInt, Field(description='Impressions from compliant records')
    ]
    non_compliant_records: Annotated[
        SchemaInt, Field(description='Number of records with non_compliant status')
    ]
    non_compliant_impressions: Annotated[
        SchemaInt, Field(description='Impressions from non_compliant records')
    ]
    not_covered_records: Annotated[
        SchemaInt,
        Field(
            description='Number of records where identifier was recognized but no data available'
        ),
    ]
    not_covered_impressions: Annotated[
        SchemaInt, Field(description='Impressions from not_covered records')
    ]
    unidentified_records: Annotated[
        SchemaInt, Field(description='Number of records where identifier type was not resolvable')
    ]
    unidentified_impressions: Annotated[
        SchemaInt, Field(description='Impressions from unidentified records')
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var compliant_impressions : int

var compliant_records : int

var model_config

var non_compliant_impressions : int

var non_compliant_records : int

var not_covered_impressions : int

var not_covered_records : int

var total_impressions : int

var total_records : int

var unidentified_impressions : int

var unidentified_records : int

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Type (*args, **kwds)

Expand source code

class Type(StrEnum):
    binary = 'binary'
    quantitative = 'quantitative'
    categorical = 'categorical'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var binary

var categorical

var quantitative

class UpdatePropertyListRequest (**data: Any)

Expand source code

class UpdatePropertyListRequest(AdcpRequest, AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list_id: Annotated[str, Field(description='ID of the property list to update')]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that owns the list. Required when the authenticated agent has access to multiple accounts; optional otherwise.'
        ),
    ] = None
    name: Annotated[str | None, Field(description='New name for the list')] = None
    description: Annotated[str | None, Field(description='New description')] = None
    base_properties: Annotated[
        list[base_property_source.BasePropertySource] | None,
        Field(
            description='Complete replacement for the base properties list (not a patch). Each entry is a discriminated union: publisher_tags (publisher_domain + tags), publisher_ids (publisher_domain + property_ids), or identifiers (direct identifiers).'
        ),
    ] = None
    filters: Annotated[
        property_list_filters.PropertyListFilters | None,
        Field(description='Complete replacement for the filters (not a patch)'),
    ] = None
    brand: Annotated[
        brand_ref.BrandReference | None,
        Field(
            description='Update brand reference. Resolved to full brand identity at execution time.'
        ),
    ] = None
    webhook_url: Annotated[
        AnyUrl | None,
        Field(
            description='Update the webhook URL for list change notifications (set to empty string to remove)'
        ),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    idempotency_key: Annotated[
        str,
        Field(
            description='Client-generated unique key for at-most-once execution. If a request with the same key has already been processed, the server returns the original response without re-processing. MUST be unique per (seller, request) pair to prevent cross-seller correlation. Use a fresh UUID v4 for each request.',
            max_length=255,
            min_length=16,
            pattern='^[A-Za-z0-9_.:-]{16,255}$',
        ),
    ]

The request message of a task in the pinned bundle's task registry.

A consumer holding one can resolve its account, decide at-most-once, echo its context and negotiate version – the whole transport-boundary job – before knowing which tool it is. issubclass(model, AdcpRequest) is the registration-time proof that a model is spec-derived rather than a hand-written parallel: a field test passes for a forged model, descent does not.

Each accessor returns the field's value, or None when this tool's schema declares no such field. Only 49 of the 87 request schemas declare an account and only 43 an idempotency_key, so asking the request is what replaces getattr(req, "account", None) against Any at the 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

• AdcpRequest
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var base_properties : list[BasePropertySource1 | BasePropertySource2 | BasePropertySource3] | None

var brand : BrandReference | None

var context : ContextObject | None

var description : str | None

var ext : ExtensionObject | None

var filters : PropertyListFilters | None

var idempotency_key : str

var list_id : str

var model_config

var name : str | None

var webhook_url : pydantic.networks.AnyUrl | None

Inherited members

• AdcpRequest:
  • get_account
  • get_adcp_major_version
  • get_adcp_version
  • get_context
  • get_idempotency_key
  • get_push_notification_config
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class UpdatePropertyListResponse (**data: Any)

Expand source code

class UpdatePropertyListResponse(AdcpResponse, AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list: Annotated[property_list.PropertyList, Field(description='The updated property list')]
    replayed: Annotated[
        StrictBool | None,
        Field(
            description="Set to true when this response was returned from the idempotency cache rather than from a fresh execution. Set to false (or omitted) when the request was executed fresh. Buyers use this to distinguish cached replays from new executions — matters for billing reconciliation, audit logs, state-machine routing (cached state-tracking fields are historical snapshots, not current state — re-read via the resource's read endpoint), and any downstream system that assumes exactly-once event semantics. `replayed` appears only when the request actually resolved through the idempotency cache. Pure reads may ignore an optional `idempotency_key`; when a seller voluntarily caches keyed reads, those responses use the same replay indicator and full cache contract."
        ),
    ] = False
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

The response message of a task in the pinned bundle's task registry.

A consumer holding one can route on task state, pick up an async task_id, split envelope from payload and log uniformly, before knowing which tool answered. Which makes one generic poll-to-terminal loop possible for all 77 tasks, where today each arm has no common type at all.

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

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

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

Ancestors

• AdcpResponse
• adcp.types.base._AdcpMessage
• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var context : ContextObject | None

var ext : ExtensionObject | None

var list : PropertyList

var model_config

var replayed : bool | None

Inherited members

• AdcpResponse:
  • get_adcp_error
  • get_context
  • get_message
  • get_replayed
  • get_status
  • get_task_id
• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class ValidatePropertyDeliveryRequest (**data: Any)

Expand source code

class ValidatePropertyDeliveryRequest(AdcpVersionEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    list_id: Annotated[str, Field(description='ID of the property list to validate against')]
    account: Annotated[
        account_ref.AccountReference | None,
        Field(
            description='Account that owns the list. Required when the authenticated agent has access to multiple accounts; optional otherwise.'
        ),
    ] = None
    records: Annotated[
        list[delivery_record.DeliveryRecord],
        Field(
            description='Delivery records to validate. Each record represents impressions delivered to a property identifier.',
            max_length=10000,
            min_length=1,
        ),
    ]
    include_compliant: Annotated[
        StrictBool | None,
        Field(
            description='Include compliant records in results (default: only return non_compliant, unmodeled, and unidentified)'
        ),
    ] = False
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

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

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

Ancestors

• AdcpVersionEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var account : AccountReference1 | AccountReference2 | None

var context : ContextObject | None

var ext : ExtensionObject | None

var include_compliant : bool | None

var list_id : str

var model_config

var records : list[DeliveryRecord]

Inherited members

• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class ValidatePropertyDeliveryResponse (**data: Any)

Expand source code

class ValidatePropertyDeliveryResponse(AdcpVersionEnvelope, ProtocolEnvelope):
    model_config = ConfigDict(
        extra='allow',
    )
    compliant: Annotated[
        StrictBool | None,
        Field(
            description='Overall compliance flag for the submitted delivery — true when every record is compliant, false when any record is non_compliant. Derived from summary.non_compliant_records === 0 but surfaced at the root as a convenience signal for buyers. Agents MAY omit this field when the response represents a partial validation (e.g., when include_compliant is false and results only contains non_compliant records); consumers SHOULD fall back to summary counts if compliant is absent.'
        ),
    ] = None
    list_id: Annotated[str, Field(description='ID of the property list validated against')]
    summary: Annotated[Summary, Field(description='Aggregate validation statistics')]
    aggregate: Annotated[
        Aggregate | None,
        Field(
            description='Optional aggregate measurements computed by the governance agent. Format and meaning are agent-specific.'
        ),
    ] = None
    authorization_summary: Annotated[
        AuthorizationSummary | None,
        Field(
            description='Aggregate authorization statistics. Only present if any records included sales_agent_url.'
        ),
    ] = None
    results: Annotated[
        list[validation_result.ValidationResult],
        Field(
            description='Per-record validation results. By default only includes non_compliant and unknown records. Set include_compliant=true to include all records.'
        ),
    ]
    validated_at: Annotated[
        AwareDatetime, Field(description='Timestamp when validation was performed')
    ]
    list_resolved_at: Annotated[
        AwareDatetime | None,
        Field(description='Timestamp of the property list resolution used for validation'),
    ] = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

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

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

Ancestors

• AdcpVersionEnvelope
• ProtocolEnvelope
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var aggregate : Aggregate | None

var authorization_summary : AuthorizationSummary | None

var compliant : bool | None

var context : ContextObject | None

var ext : ExtensionObject | None

var list_id : str

var list_resolved_at : pydantic.types.AwareDatetime | None

var model_config

var results : list[ValidationResult]

var summary : Summary

var validated_at : pydantic.types.AwareDatetime

Inherited members

• AdcpVersionEnvelope:
  • model_dump
  • model_dump_json
  • model_summary

class ValidationResult (**data: Any)

Expand source code

class ValidationResult(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    identifier: Annotated[
        identifier_1.Identifier, Field(description='The identifier that was validated')
    ]
    record_id: Annotated[
        str | None, Field(description='Client-provided ID from the delivery record (if provided)')
    ] = None
    status: Annotated[
        Status,
        Field(
            description='Validation status: compliant (in list), non_compliant (not in list), not_covered (identifier recognized but no data available), unidentified (identifier type not resolvable by this governance agent)'
        ),
    ]
    impressions: Annotated[
        SchemaInt, Field(description='Number of impressions from this record', ge=0)
    ]
    features: Annotated[
        list[Feature] | None,
        Field(
            description='Per-feature breakdown for this record. SHOULD include all failed and warning features. MAY include passed features. For property validation the buyer authored the requirement, so the `requirement` that was not met MAY be echoed back on failures — this is contract data, not evaluator IP.'
        ),
    ] = None
    authorization: Annotated[
        authorization_result.AuthorizationResult | None,
        Field(
            description='Authorization validation result (only present if sales_agent_url was provided in the delivery record)'
        ),
    ] = None
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var authorization : AuthorizationResult | None

var ext : ExtensionObject | None

var features : list[Feature] | None

var identifier : Identifier

var impressions : int

var model_config

var record_id : str | None

var status : Status

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Violation (**data: Any)

Expand source code

class Violation(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    code: Annotated[str, Field(description='Machine-readable violation code')]
    message: Annotated[str, Field(description='Human-readable violation description')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

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

Raises [ValidationError][pydantic_core.ValidationError] if 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

Class variables

var code : str

var message : str

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary