Module adcp.types.generated_poc.governance.sync_plans_request

Classes

class Budget (**data: Any)
Expand source code 
class Budget(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    total: Annotated[float, Field(description='Total authorized budget.')]
    currency: Annotated[str, Field(description='ISO 4217 currency code.')]
    authority_level: Annotated[
        budget_authority_level.BudgetAuthorityLevel,
        Field(description='Budget authority level for the orchestrator agent.'),
    ]
    per_seller_max_pct: Annotated[
        float | None,
        Field(description='Maximum percentage of budget that can go to a single seller.'),
    ] = None
    reallocation_threshold: Annotated[
        float | None,
        Field(
            description='Amount above which reallocations require escalation (for agent_limited).'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var authority_level : BudgetAuthorityLevel
var currency : str
var model_config
var per_seller_max_pct : float | None
var reallocation_threshold : float | None
var total : float

Inherited members

class BudgetLimit (**data: Any)
Expand source code 
class BudgetLimit(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    amount: float
    currency: str

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Subclasses

Class variables

var amount : float
var currency : str
var model_config

Inherited members

class Channels (**data: Any)
Expand source code 
class Channels(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    required: Annotated[
        list[channels_1.MediaChannel] | None,
        Field(description='Channels that must be included in the media mix.'),
    ] = None
    allowed: Annotated[
        list[channels_1.MediaChannel] | None,
        Field(description='Channels the orchestrator may use.'),
    ] = None
    mix_targets: Annotated[
        dict[str, MixTargets] | None,
        Field(description='Target allocation ranges per channel, keyed by channel ID.'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var allowed : list[MediaChannel] | None
var mix_targets : dict[str, MixTargets] | None
var model_config
var required : list[MediaChannel] | None

Inherited members

class Delegation (**data: Any)
Expand source code 
class Delegation(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    agent_url: Annotated[AnyUrl, Field(description='URL of the delegated agent.')]
    authority: Annotated[
        delegation_authority.DelegationAuthority,
        Field(description='Authority level granted to this agent.'),
    ]
    budget_limit: Annotated[
        BudgetLimit | None,
        Field(
            description="Maximum budget this agent can commit. When omitted, the agent can commit up to the plan's total budget."
        ),
    ] = None
    markets: Annotated[
        list[str] | None,
        Field(
            description='ISO 3166-1/3166-2 codes this agent is authorized for. When omitted, the agent can operate in all plan markets.'
        ),
    ] = None
    expires_at: Annotated[
        AwareDatetime | None,
        Field(
            description='When this delegation expires. After expiration, the governance agent denies actions from this agent.'
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var agent_url : pydantic.networks.AnyUrl
var authority : DelegationAuthority
var budget_limit : BudgetLimit | None
var expires_at : pydantic.types.AwareDatetime | None
var markets : list[str] | None
var model_config

Inherited members

class Flight (**data: Any)
Expand source code 
class Flight(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    start: Annotated[AwareDatetime, Field(description='Flight start (ISO 8601).')]
    end: Annotated[AwareDatetime, Field(description='Flight end (ISO 8601).')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var end : pydantic.types.AwareDatetime
var model_config
var start : pydantic.types.AwareDatetime

Inherited members

class MixTargets (**data: Any)
Expand source code 
class MixTargets(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    min_pct: float | None = None
    max_pct: float | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var max_pct : float | None
var min_pct : float | None
var model_config

Inherited members

class Plan (**data: Any)
Expand source code 
class Plan(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    plan_id: Annotated[str, Field(description='Unique identifier for this plan.')]
    brand: Annotated[
        brand_ref.BrandReference,
        Field(
            description="Brand or organization being governed. For campaign plans, the governance agent resolves the brand's compliance configuration. For portfolio plans, this is the holding company or parent organization."
        ),
    ]
    objectives: Annotated[
        str,
        Field(
            description='Natural language campaign objectives. Used for strategic alignment validation.'
        ),
    ]
    budget: Annotated[Budget, Field(description='Budget authorization parameters.')]
    channels: Annotated[
        Channels | None,
        Field(description='Channel constraints. If omitted, all channels are allowed.'),
    ] = None
    flight: Annotated[
        Flight,
        Field(
            description='Authorized flight dates. Media buys with dates outside this window are rejected.'
        ),
    ]
    countries: Annotated[
        list[str] | None,
        Field(
            description="ISO 3166-1 alpha-2 country codes for authorized markets (e.g., ['US', 'GB']). The governance agent rejects media buys targeting outside these countries and resolves applicable policies by matching against policy jurisdictions.",
            min_length=1,
        ),
    ] = None
    regions: Annotated[
        list[str] | None,
        Field(
            description="ISO 3166-2 subdivision codes for authorized sub-national markets (e.g., ['US-MA', 'US-CA']). When present, the governance agent restricts buys to these specific regions rather than the full country. Use for campaigns limited to specific states or provinces (e.g., cannabis in legal states). Policy resolution matches against both the subdivision and its parent country.",
            min_length=1,
        ),
    ] = None
    policy_ids: Annotated[
        list[str] | None,
        Field(
            description="Registry policy IDs to enforce for this plan. The governance agent resolves full policy definitions from the registry and evaluates actions against them. Intersected with the plan's countries/regions to activate only geographically relevant policies."
        ),
    ] = None
    custom_policies: Annotated[
        list[str] | None,
        Field(
            description="Natural language policy statements specific to this campaign (e.g., 'No advertising adjacent to competitor content'). Applied regardless of geography."
        ),
    ] = None
    approved_sellers: Annotated[
        list[AnyUrl] | None,
        Field(description='List of approved seller agent URLs. null means any seller.'),
    ] = None
    delegations: Annotated[
        list[Delegation] | None,
        Field(
            description="Agents authorized to execute against this plan. Each delegation scopes an agent's authority by budget, markets, and expiration. The governance agent validates that the requesting agent matches a delegation before approving actions."
        ),
    ] = None
    portfolio: Annotated[
        Portfolio | None,
        Field(
            description='Portfolio-level governance constraints. When present, this plan acts as a portfolio plan that governs member plans. Portfolio plans define cross-brand constraints that no individual brand plan can override.'
        ),
    ] = None
    mode: Annotated[
        governance_mode.GovernanceMode | None,
        Field(
            description="Governance enforcement mode for this plan. 'enforce': denied actions are blocked. 'advisory': denied actions proceed with findings logged. 'audit': all actions proceed, findings logged. Defaults to 'enforce' if omitted."
        ),
    ] = governance_mode.GovernanceMode.enforce
    ext: ext_1.ExtensionObject | None = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var approved_sellers : list[pydantic.networks.AnyUrl] | None
var brand : BrandReference
var budget : Budget
var channels : Channels | None
var countries : list[str] | None
var custom_policies : list[str] | None
var delegations : list[Delegation] | None
var ext : ExtensionObject | None
var flight : Flight
var mode : GovernanceMode | None
var model_config
var objectives : str
var plan_id : str
var policy_ids : list[str] | None
var portfolio : Portfolio | None
var regions : list[str] | None

Inherited members

class Portfolio (**data: Any)
Expand source code 
class Portfolio(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    member_plan_ids: Annotated[
        list[str],
        Field(
            description='Plan IDs governed by this portfolio plan. The governance agent validates member plan actions against portfolio constraints.'
        ),
    ]
    total_budget_cap: Annotated[
        TotalBudgetCap | None,
        Field(description='Maximum aggregate budget across all member plans.'),
    ] = None
    shared_policy_ids: Annotated[
        list[str] | None,
        Field(
            description='Registry policy IDs enforced across all member plans, regardless of individual brand configuration.'
        ),
    ] = None
    shared_exclusions: Annotated[
        list[str] | None,
        Field(
            description="Natural language exclusion rules applied across all member plans (e.g., 'No advertising on properties owned by competitor holding companies')."
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var member_plan_ids : list[str]
var model_config
var shared_exclusions : list[str] | None
var shared_policy_ids : list[str] | None
var total_budget_cap : TotalBudgetCap | None

Inherited members

class SyncPlansRequest (**data: Any)
Expand source code 
class SyncPlansRequest(AdCPBaseModel):
    model_config = ConfigDict(
        extra='forbid',
    )
    plans: Annotated[list[Plan], Field(description='One or more campaign plans to sync.')]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var model_config
var plans : list[Plan]

Inherited members

class TotalBudgetCap (**data: Any)
Expand source code 
class TotalBudgetCap(BudgetLimit):
    pass

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so that 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. Consumers who want strict validation can override with extra='forbid'.

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

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

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

Ancestors

Class variables

var model_config

Inherited members