Module adcp.types.v31

Public AdCP 3.1 boundary models with a generated static typing stub.

Classes

class AcquireRightsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class AcquireRightsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ActivateSignalRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ActivateSignalResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class BuildCreativeInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class BuildCreativeRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class BuildCreativeResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class BuildCreativeSubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class BuildCreativeWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CalibrateContentRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CalibrateContentResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CheckGovernanceRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CheckGovernanceResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ComplyTestControllerRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ComplyTestControllerResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ContextMatchRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ContextMatchResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateCollectionListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateCollectionListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateContentStandardsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateContentStandardsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateMediaBuyInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateMediaBuyRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateMediaBuyResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateMediaBuySubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreateMediaBuyWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreatePropertyListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreatePropertyListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreativeApprovalRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class CreativeApprovalResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class DeleteCollectionListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class DeleteCollectionListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class DeletePropertyListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class DeletePropertyListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetAccountFinancialsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetAccountFinancialsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetAdcpCapabilitiesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetAdcpCapabilitiesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetBrandIdentityRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetBrandIdentityResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCollectionListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCollectionListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetContentStandardsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetContentStandardsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCreativeDeliveryRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCreativeDeliveryResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCreativeFeaturesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetCreativeFeaturesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuyArtifactsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuyArtifactsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuyDeliveryRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuyDeliveryResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuysRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetMediaBuysResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetPlanAuditLogsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetPlanAuditLogsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetProductsInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetProductsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetProductsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetProductsSubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetProductsWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetPropertyListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetPropertyListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetRightsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetRightsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetSignalsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetSignalsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetSignalsSubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetSignalsWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetTaskStatusRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class GetTaskStatusResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class IdentityMatchRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class IdentityMatchResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListAccountsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListAccountsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCollectionListsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCollectionListsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListContentStandardsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListContentStandardsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCreativeFormatsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCreativeFormatsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCreativesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListCreativesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListPropertyListsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListPropertyListsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListTasksRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListTasksResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListTransformersRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ListTransformersResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class LogEventRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class LogEventResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class PackageRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class PreviewCreativeRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class PreviewCreativeResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ProvidePerformanceFeedbackRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ProvidePerformanceFeedbackResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ProviderIdentityMatchResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ReportPlanOutcomeRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ReportPlanOutcomeResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ReportUsageRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ReportUsageResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SearchBrandsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SearchBrandsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiGetOfferingRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiGetOfferingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiInitiateSessionRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiInitiateSessionResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiSendMessageRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiSendMessageResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiTerminateSessionRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SiTerminateSessionResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class StaleResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncAccountsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncAccountsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncAudiencesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncAudiencesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCatalogsInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCatalogsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCatalogsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCatalogsSubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCatalogsWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCreativesInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCreativesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCreativesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCreativesSubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncCreativesWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncEventSourcesRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncEventSourcesResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncGovernanceRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncGovernanceResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncPlansRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class SyncPlansResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class TasksGetRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class TasksGetResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class TasksListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class TasksListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateCollectionListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateCollectionListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateContentStandardsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateContentStandardsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateMediaBuyInputRequiredResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateMediaBuyRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateMediaBuyResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateMediaBuySubmittedResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateMediaBuyWorkingResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdatePropertyListRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdatePropertyListResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateRightsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class UpdateRightsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidateContentDeliveryRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidateContentDeliveryResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidateInputRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidateInputResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidatePropertyDeliveryRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class ValidatePropertyDeliveryResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class VerifyBrandClaimRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class VerifyBrandClaimResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class VerifyBrandClaimsRequest (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema

class VerifyBrandClaimsResponse (root: dict[str, Any] | None = None, **data: Any)

Dict-shaped Pydantic model that enforces one bundled schema version.

Keyword construction and attribute access intentionally mirror ordinary generated request models while retaining the exact JSON Schema as the validation authority. The companion module stubs provide static field information. This runtime wrapper remains intended for boundary validation and schema generation, not as a base class for adopter-defined models.

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

• VersionedSchemaModel
• pydantic.root_model.RootModel[dict[str, Any]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var optional_fields : ClassVar[frozenset[str]]

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

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

var schema_tool_name : ClassVar[str]

var schema_version : ClassVar[str]

Inherited members

• VersionedSchemaModel:
  • model_json_schema