Module adcp.types.domains.media_buy.refine_proposals_response

Classes

class Outcome (*args, **kwds)

Expand source code

class Outcome(StrEnum):
    revised = 'revised'
    partial = 'partial'
    finalized = 'finalized'
    unable = 'unable'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var finalized

var partial

var revised

var unable

class Proposal (**data: Any)

Expand source code

class Proposal(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    proposal_id: Annotated[str, Field(max_length=255, min_length=1)]
    proposal_kind: ProposalKind
    parent_proposal_id: Annotated[
        str,
        Field(
            description="Immediate predecessor this snapshot was forked from. Every proposal produced by refine_proposals carries it, equal to the request's source proposal_id, so negotiation lineage is reconstructible from proposals alone.",
            max_length=255,
            min_length=1,
        ),
    ]
    media_buy_id: Annotated[str | None, Field(min_length=1)] = None
    opportunity_id: Annotated[
        str | None,
        Field(
            description='Buyer planning cycle associated with this proposal. Revisions inherit it; it does not participate in proposal identity.',
            max_length=255,
            min_length=1,
            pattern='^[A-Za-z0-9_.:-]{1,255}$',
        ),
    ] = None
    base_media_buy_revision: Annotated[SchemaInt | None, Field(ge=1)] = None
    proposal_status: Annotated[
        Literal['draft'],
        Field(
            description='draft is indicative and unreserved; committed has firm terms with inventory reserved until expires_at; accepted is the historical snapshot attached to a MediaBuy.',
            title='Proposal Status',
        ),
    ] = 'draft'
    accepted_at: AwareDatetime | None = None
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            description='For a draft, the indicative-terms freshness deadline. For a committed proposal, the inventory-hold deadline.'
        ),
    ] = None
    name: Annotated[str, Field(max_length=500, min_length=1)]
    description: Annotated[str | None, Field(max_length=2000)] = None
    brief_alignment: Annotated[str | None, Field(max_length=2000)] = None
    commercial_terms: commercial_terms_1.CommercialTerms
    terms_digest: Annotated[
        str,
        Field(
            description='Base64url SHA-256 digest of the RFC 8785 JCS serialization of commercial_terms, prefixed with sha256:.',
            pattern='^sha256:[A-Za-z0-9_-]{43}$',
        ),
    ]
    insertion_order: insertion_order_1.InsertionOrder | None = None
    total_budget_guidance: Annotated[
        TotalBudgetGuidance | None,
        Field(
            description="Optional budget guidance for this proposal — the planning answer to criteria.outcome_target and to open-budget briefs. commercial_terms.total_budget remains the concrete figure the plan is priced at; this band expresses the seller's recommended range around it. When criteria.outcome_target carries cost_per, the cost answer is commercial_terms.bidding.cost_per and this band's currency equals cost_per.currency."
        ),
    ] = None
    forecast: Annotated[
        canonical_delivery_forecast.CanonicalDeliveryForecast | None,
        Field(
            description="Aggregate forecasted delivery for the proposal. For outcome_target requests, points carry the goal's metric or event key in metrics; with cost_per, that is the goal volume planned under the commercial_terms.bidding policy, and currency equals cost_per.currency."
        ),
    ] = 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

Subclasses

• Proposal2
• Proposal4
• Proposal5

Class variables

var accepted_at : pydantic.types.AwareDatetime | None

var base_media_buy_revision : int | None

var brief_alignment : str | None

var commercial_terms : CommercialTerms

var description : str | None

var expires_at : pydantic.types.AwareDatetime | None

var forecast : CanonicalDeliveryForecast | None

var insertion_order : InsertionOrder | None

var media_buy_id : str | None

var model_config

var name : str

var opportunity_id : str | None

var parent_proposal_id : str

var proposal_id : str

var proposal_kind : ProposalKind

var proposal_status : Literal['draft']

var terms_digest : str

var total_budget_guidance : TotalBudgetGuidance | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Proposal2 (**data: Any)

Expand source code

class Proposal2(Proposal):
    pass

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

• Proposal
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• Proposal:
  • model_dump
  • model_dump_json
  • model_summary

class Proposal3 (**data: Any)

Expand source code

class Proposal3(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    proposal_id: Annotated[str, Field(max_length=255, min_length=1)]
    proposal_kind: ProposalKind
    parent_proposal_id: Annotated[
        str,
        Field(
            description="Immediate predecessor this snapshot was forked from. Every proposal produced by refine_proposals carries it, equal to the request's source proposal_id, so negotiation lineage is reconstructible from proposals alone.",
            max_length=255,
            min_length=1,
        ),
    ]
    media_buy_id: Annotated[str | None, Field(min_length=1)] = None
    opportunity_id: Annotated[
        str | None,
        Field(
            description='Buyer planning cycle associated with this proposal. Revisions inherit it; it does not participate in proposal identity.',
            max_length=255,
            min_length=1,
            pattern='^[A-Za-z0-9_.:-]{1,255}$',
        ),
    ] = None
    base_media_buy_revision: Annotated[SchemaInt | None, Field(ge=1)] = None
    proposal_status: Annotated[
        Literal['committed'],
        Field(
            description='draft is indicative and unreserved; committed has firm terms with inventory reserved until expires_at; accepted is the historical snapshot attached to a MediaBuy.',
            title='Proposal Status',
        ),
    ] = 'committed'
    accepted_at: AwareDatetime | None = None
    expires_at: Annotated[
        AwareDatetime,
        Field(
            description='For a draft, the indicative-terms freshness deadline. For a committed proposal, the inventory-hold deadline.'
        ),
    ]
    name: Annotated[str, Field(max_length=500, min_length=1)]
    description: Annotated[str | None, Field(max_length=2000)] = None
    brief_alignment: Annotated[str | None, Field(max_length=2000)] = None
    commercial_terms: commercial_terms_1.CommercialTerms
    terms_digest: Annotated[
        str,
        Field(
            description='Base64url SHA-256 digest of the RFC 8785 JCS serialization of commercial_terms, prefixed with sha256:.',
            pattern='^sha256:[A-Za-z0-9_-]{43}$',
        ),
    ]
    insertion_order: insertion_order_1.InsertionOrder | None = None
    total_budget_guidance: Annotated[
        TotalBudgetGuidance | None,
        Field(
            description="Optional budget guidance for this proposal — the planning answer to criteria.outcome_target and to open-budget briefs. commercial_terms.total_budget remains the concrete figure the plan is priced at; this band expresses the seller's recommended range around it. When criteria.outcome_target carries cost_per, the cost answer is commercial_terms.bidding.cost_per and this band's currency equals cost_per.currency."
        ),
    ] = None
    forecast: Annotated[
        canonical_delivery_forecast.CanonicalDeliveryForecast | None,
        Field(
            description="Aggregate forecasted delivery for the proposal. For outcome_target requests, points carry the goal's metric or event key in metrics; with cost_per, that is the goal volume planned under the commercial_terms.bidding policy, and currency equals cost_per.currency."
        ),
    ] = 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

Subclasses

• Proposal6

Class variables

var accepted_at : pydantic.types.AwareDatetime | None

var base_media_buy_revision : int | None

var brief_alignment : str | None

var commercial_terms : CommercialTerms

var description : str | None

var expires_at : pydantic.types.AwareDatetime

var forecast : CanonicalDeliveryForecast | None

var insertion_order : InsertionOrder | None

var media_buy_id : str | None

var model_config

var name : str

var opportunity_id : str | None

var parent_proposal_id : str

var proposal_id : str

var proposal_kind : ProposalKind

var proposal_status : Literal['committed']

var terms_digest : str

var total_budget_guidance : TotalBudgetGuidance | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Proposal4 (**data: Any)

Expand source code

class Proposal4(Proposal):
    pass

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

• Proposal
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• Proposal:
  • model_dump
  • model_dump_json
  • model_summary

class Proposal5 (**data: Any)

Expand source code

class Proposal5(Proposal):
    pass

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

• Proposal
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• Proposal:
  • model_dump
  • model_dump_json
  • model_summary

class Proposal6 (**data: Any)

Expand source code

class Proposal6(Proposal3):
    pass

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

• Proposal3
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

Inherited members

• Proposal3:
  • model_dump
  • model_dump_json
  • model_summary

class ProposalKind (*args, **kwds)

Expand source code

class ProposalKind(StrEnum):
    new_media_buy = 'new_media_buy'
    media_buy_update = 'media_buy_update'
    media_buy_cancellation = 'media_buy_cancellation'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var media_buy_cancellation

var media_buy_update

var new_media_buy

class ProposalStatus (*args, **kwds)

Expand source code

class ProposalStatus(StrEnum):
    draft = 'draft'
    committed = 'committed'
    accepted = 'accepted'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var accepted

var committed

var draft

class RefineProposalsResponse1 (**data: Any)

Expand source code

class RefineProposalsResponse1(AdcpResponse, AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    adcp_version: Annotated[
        str | None,
        Field(
            description='Release-precision AdCP version (VERSION.RELEASE, e.g. "3.0", "3.1", "3.1-beta"). On a request: the buyer\'s release pin — the seller validates against its supported_versions and returns VERSION_UNSUPPORTED on cross-major mismatch, or downshifts to the highest supported release within the same major. On a response: the release the seller actually served — clients SHOULD validate the response against that release\'s schema, not against their pin. Patches are not negotiated; surface them as build_version on capabilities for operational visibility. When omitted, falls back to adcp_major_version (deprecated) or server default. Buyers SHOULD emit both adcp_version and adcp_major_version through 3.x to remain compatible with sellers that only read the legacy field. NORMALIZATION: SDKs that read full-semver values from bundle metadata (e.g. ComplianceIndex.published_version = "3.1.0-beta.1") MUST normalize to release-precision ("3.1-beta.1") before emitting on the wire — meta-field values are NOT valid wire values.',
            examples=['3.0', '3.1', '3.1-beta', '3.1-rc.1'],
            pattern='^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?)?$',
        ),
    ] = None
    results: Annotated[
        list[Results8] | Results,
        Field(
            description="Ordered results. If any result is finalized, every result MUST be finalized; a finalize batch either creates every requested hold or none. Every returned proposal carries parent_proposal_id equal to the result's source_proposal_id, making negotiation lineage reconstructible from the proposals alone.",
            min_length=1,
        ),
    ]
    products: Annotated[
        list[canonical_product.CanonicalProduct],
        Field(
            description="Canonical products needed to evaluate the resulting terms. For revised or partial results whose effective criteria contain property or collection lists, each affected product MUST carry fresh list_applications receipts from the revision's product reevaluation. Finalization changes no terms and MAY repeat the receipts already bound to the source proposal rather than reevaluating them."
        ),
    ]
    status: Literal['completed'] = 'completed'
    task_id: Annotated[str | None, Field(min_length=1)] = None
    message: Annotated[str | None, Field(max_length=2000)] = None
    errors: list[error.Error] | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    replayed: Literal[True] | 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
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var context : ContextObject | None

var errors : list[Error] | None

var ext : ExtensionObject | None

var message : str | None

var model_config

var products : list[CanonicalProduct]

var replayed : Literal[True] | None

var results : list[Results9 | Results10 | Results11 | Results12] | Results

var status : Literal['completed']

var task_id : str | None

Inherited members

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

class RefineProposalsResponse2 (**data: Any)

Expand source code

class RefineProposalsResponse2(AdcpResponse, CompactTaskSubmitted):
    model_config = ConfigDict(
        extra='forbid',
    )
    adcp_version: Annotated[
        str | None,
        Field(
            description='Release-precision AdCP version (VERSION.RELEASE, e.g. "3.0", "3.1", "3.1-beta"). On a request: the buyer\'s release pin — the seller validates against its supported_versions and returns VERSION_UNSUPPORTED on cross-major mismatch, or downshifts to the highest supported release within the same major. On a response: the release the seller actually served — clients SHOULD validate the response against that release\'s schema, not against their pin. Patches are not negotiated; surface them as build_version on capabilities for operational visibility. When omitted, falls back to adcp_major_version (deprecated) or server default. Buyers SHOULD emit both adcp_version and adcp_major_version through 3.x to remain compatible with sellers that only read the legacy field. NORMALIZATION: SDKs that read full-semver values from bundle metadata (e.g. ComplianceIndex.published_version = "3.1.0-beta.1") MUST normalize to release-precision ("3.1-beta.1") before emitting on the wire — meta-field values are NOT valid wire values.',
            examples=['3.0', '3.1', '3.1-beta', '3.1-rc.1'],
            pattern='^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?)?$',
        ),
    ] = None
    results: Annotated[
        list[Results14] | Results | None,
        Field(
            description="Ordered results. If any result is finalized, every result MUST be finalized; a finalize batch either creates every requested hold or none. Every returned proposal carries parent_proposal_id equal to the result's source_proposal_id, making negotiation lineage reconstructible from the proposals alone.",
            min_length=1,
        ),
    ] = None
    products: Annotated[
        list[canonical_product.CanonicalProduct] | None,
        Field(
            description="Canonical products needed to evaluate the resulting terms. For revised or partial results whose effective criteria contain property or collection lists, each affected product MUST carry fresh list_applications receipts from the revision's product reevaluation. Finalization changes no terms and MAY repeat the receipts already bound to the source proposal rather than reevaluating them."
        ),
    ] = None
    status: Status | None = None
    task_id: Annotated[str | None, Field(min_length=1)] = None
    message: Annotated[str | None, Field(max_length=2000)] = None
    errors: list[error.Error] | None = None
    context: context_1.ContextObject | None = None
    ext: ext_1.ExtensionObject | None = None
    replayed: Literal[True] | 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
• CompactTaskSubmitted
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var adcp_version : str | None

var context : ContextObject | None

var errors : list[Error] | None

var ext : ExtensionObject | None

var message : str | None

var model_config

var products : list[CanonicalProduct] | None

var replayed : Literal[True] | None

var results : list[Results15 | Results16 | Results17 | Results18] | Results | None

var status : Status | None

var task_id : str | None

Inherited members

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

class Results (**data: Any)

Expand source code

class Results(AdCPBaseModel):
    pass

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

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results10 (**data: Any)

Expand source code

class Results10(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['partial'] = 'partial'
    proposal: canonical_proposal.CanonicalProposal | None = None
    proposals: Annotated[
        list[Proposal2],
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ]
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ]
    reason: Annotated[str, Field(min_length=1)]
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['partial']

var proposal : CanonicalProposal | None

var proposals : list[Proposal2]

var reason : str

var reason_code : ProposalRefinementReason

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results11 (**data: Any)

Expand source code

class Results11(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['finalized'] = 'finalized'
    proposal: Annotated[
        Proposal3,
        Field(
            description='Compact immutable proposal for the AdCP 3.2 lifecycle. commercial_terms is the sole authoritative commercial envelope; narrative fields do not duplicate legacy allocation or creative graphs.',
            title='Canonical Proposal',
        ),
    ]
    proposals: Annotated[
        list[canonical_proposal.CanonicalProposal] | None,
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ] = None
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason | None,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ] = None
    reason: Annotated[str | None, Field(min_length=1)] = None
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['finalized']

var proposal : Proposal3

var proposals : list[CanonicalProposal] | None

var reason : str | None

var reason_code : ProposalRefinementReason | None

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results12 (**data: Any)

Expand source code

class Results12(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['unable'] = 'unable'
    proposal: canonical_proposal.CanonicalProposal | None = None
    proposals: Annotated[
        list[canonical_proposal.CanonicalProposal] | None,
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ] = None
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ]
    reason: Annotated[str, Field(min_length=1)]
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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

Subclasses

• Results18

Class variables

var model_config

var outcome : Literal['unable']

var proposal : CanonicalProposal | None

var proposals : list[CanonicalProposal] | None

var reason : str

var reason_code : ProposalRefinementReason

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results15 (**data: Any)

Expand source code

class Results15(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['revised'] = 'revised'
    proposal: canonical_proposal.CanonicalProposal | None = None
    proposals: Annotated[
        list[Proposal4],
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ]
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason | None,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ] = None
    reason: Annotated[str | None, Field(min_length=1)] = None
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['revised']

var proposal : CanonicalProposal | None

var proposals : list[Proposal4]

var reason : str | None

var reason_code : ProposalRefinementReason | None

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results16 (**data: Any)

Expand source code

class Results16(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['partial'] = 'partial'
    proposal: canonical_proposal.CanonicalProposal | None = None
    proposals: Annotated[
        list[Proposal5],
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ]
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ]
    reason: Annotated[str, Field(min_length=1)]
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['partial']

var proposal : CanonicalProposal | None

var proposals : list[Proposal5]

var reason : str

var reason_code : ProposalRefinementReason

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results17 (**data: Any)

Expand source code

class Results17(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['finalized'] = 'finalized'
    proposal: Annotated[
        Proposal6,
        Field(
            description='Compact immutable proposal for the AdCP 3.2 lifecycle. commercial_terms is the sole authoritative commercial envelope; narrative fields do not duplicate legacy allocation or creative graphs.',
            title='Canonical Proposal',
        ),
    ]
    proposals: Annotated[
        list[canonical_proposal.CanonicalProposal] | None,
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ] = None
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason | None,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ] = None
    reason: Annotated[str | None, Field(min_length=1)] = None
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['finalized']

var proposal : Proposal6

var proposals : list[CanonicalProposal] | None

var reason : str | None

var reason_code : ProposalRefinementReason | None

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Results18 (**data: Any)

Expand source code

class Results18(Results12):
    outcome: Literal['unable'] = 'unable'

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

• Results12
• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var model_config

var outcome : Literal['unable']

Inherited members

• Results12:
  • model_dump
  • model_dump_json
  • model_summary

class Results9 (**data: Any)

Expand source code

class Results9(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    source_proposal_id: Annotated[str, Field(min_length=1)]
    outcome: Literal['revised'] = 'revised'
    proposal: canonical_proposal.CanonicalProposal | None = None
    proposals: Annotated[
        list[Proposal],
        Field(
            description='Draft successors produced for a revision. Without alternatives this contains one proposal. With alternatives.count, revised contains exactly that many proposals with unique terms_digest values; fewer or commercially duplicate proposals require partial.',
            min_length=1,
        ),
    ]
    reason_code: Annotated[
        proposal_refinement_reason.ProposalRefinementReason | None,
        Field(
            description='Single most-significant code for this result. constraint_unsatisfiable takes precedence over every other code; an alternatives shortfall alongside an unsatisfied constraint remains visible through proposals.length.'
        ),
    ] = None
    reason: Annotated[str | None, Field(min_length=1)] = None
    unsatisfied_constraints: Annotated[
        list[UnsatisfiedConstraint] | None,
        Field(
            description='Stable keys from the request constraints object that were not satisfied by every returned draft. A result carrying any key here MUST use outcome partial or unable, never revised.',
            min_length=1,
        ),
    ] = None
    unsatisfied_product_changes: Annotated[
        product_change_map.ProductChangeMap | None,
        Field(
            description='Requested product actions not satisfied by every returned draft. This is a subset of the request product_changes map and is valid only on partial or unable results.'
        ),
    ] = None
    suggestions: Annotated[list[Suggestion] | None, Field(min_length=1)] = None
    targeting_resolution: Annotated[
        get_products_targeting_resolution.ProductDiscoveryTargetingResolution | None,
        Field(
            description="Confirmation of structured targeting interpreted from this refinement's explicit hard prose instructions. Required when that interpretation materially affects the revised proposal's eligibility, pricing, or forecast; otherwise a best practice."
        ),
    ] = 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 outcome : Literal['revised']

var proposal : CanonicalProposal | None

var proposals : list[Proposal]

var reason : str | None

var reason_code : ProposalRefinementReason | None

var source_proposal_id : str

var suggestions : list[Suggestion] | None

var targeting_resolution : ProductDiscoveryTargetingResolution | None

var unsatisfied_constraints : list[UnsatisfiedConstraint] | None

var unsatisfied_product_changes : ProductChangeMap | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Status (*args, **kwds)

Expand source code

class Status(StrEnum):
    completed = 'completed'
    submitted = 'submitted'

Enum where members are also (and must be) strings

Ancestors

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

Class variables

var completed

var submitted

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

Expand source code

class Suggestion(UnsatisfiedConstraint):
    pass

A str generated from a JSON Schema string root.

Ancestors

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

class TotalBudgetGuidance (**data: Any)

Expand source code

class TotalBudgetGuidance(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min: Annotated[StrictFloat | None, Field(ge=0.0)] = None
    recommended: Annotated[StrictFloat | None, Field(ge=0.0)] = None
    max: Annotated[StrictFloat | None, Field(ge=0.0)] = None
    currency: Annotated[str, Field(pattern='^[A-Z]{3}$')]

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 currency : str

var max : float | None

var min : float | None

var model_config

var recommended : float | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

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

Expand source code

class UnsatisfiedConstraint(ScalarStr):
    __slots__ = ()
    _constraints = {'min_length': 1}

A str generated from a JSON Schema string root.

Ancestors

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

Subclasses

• Suggestion